DEV Community

Sui Gn
Sui Gn

Posted on

T A: Replication Should Not Change Audience

#ai #programming #architecture #opensource

If you build with encrypted data, local-first sync, or AI agents that hold user secrets — you've hit the same bug. You replicate topology T, and audience A changes. That's the inversion. .me fixes it structurally.

Keywords: encrypted audiences, end-to-end encryption, E2E, local-first software, personal data store, user-owned data, zero-knowledge architecture, secret scoping, namespace resolution protocol, NRP, personal semantic kernel, data replication vs authorization.

The bug every builder hits

You do everything right:

  • Data is end-to-end encrypted
  • You host a replica, backup to second device, add offline sync
  • You forward a task to another agent

And suddenly readability expands. Or the host can read it. Or you need a new permission system.

Formally:

replicate(T) → change(A)   // the bug
Enter fullscreen mode Exit fullscreen mode

Replication changes audience. Topology leaks into authorization. Every local-first, E2E, and agent framework that doesn't solve this ends up re-building ACLs on top of sync.

What we want is:

replicate(T) ↛ change(A)   // T ⊥ A
Enter fullscreen mode Exit fullscreen mode

Topology and audience are orthogonal. You can move data anywhere — new host, new device, new monad, backup — without changing who can read it.

This is The Algebra of Encrypted Audiences. Not a policy. A structural property of the kernel.

Why current stacks invert both

Most systems today:

identity = distributed (N fragmented accounts per platform)
data     = centralized (locked to platform that captured it)
Enter fullscreen mode Exit fullscreen mode

You have 12 logins, but your photos can't leave Google without breaking sharing.

The correction:

identity = centralized (one root)
data     = distributed (T independent of A)
Enter fullscreen mode Exit fullscreen mode

One seed. One identity function. Unconstrained topology.

In [.me](https://neurons-me.github.io/.me/):

identityHash(K) = keccak256("this.me/identity:v1::" + K.seed)
Enter fullscreen mode Exit fullscreen mode

seed never leaves the kernel. Every context — work, family, agent — is me.as(context), not a new account.

How .me implements T ⊥ A, verified

This is not a whitepaper promise. It's source-verified behavior in the kernel:

const me = new ME() as any;

me.security _; // path-bound secret scope
me.security.keys.api("sk_live_xxx");

me("security")           // undefined — root is stealth, not in public index
me("security.keys.api")  // "sk_live_xxx" — readable with full path

me.explain("security.keys.api")
// → shows derivation chain, masks raw to unauthorized readers: ●●●●
Enter fullscreen mode Exit fullscreen mode
  • _ is structural secrecy, not a flag. The public index was never populated with that prefix. A / ¬A at the storage layer.
  • ~ resets derivation. __ creates structural pointers that dereference without copying secrets.
  • explain() is auditable disclosure, not console.log hiding.

You can now replicate(T) — backup the monad, mount it on another host, sync via NRP — and A doesn't change. No new ACL.

Benchmarks: secret-scope stealth holds at scale — secret scope p50/p95/p99 across node counts — and public + secret coexistence never leaks.

For agent builders: this is why your agents leak

If your agent holds user wallet, keys, memories:

  1. You put secrets in env / vector store
  2. You replicate conversation to another agent to help
  3. Audience just expanded to that agent + its host + its logs

You patched it with another proxy. You need me.wallet _ — a branch that computes internally, never resolves from public index, but me.profile.card -> me.wallet can still dereference it when authorized.

4 agents, same graph, 4 different answers to canProceed — without 4 copies. That's Robots That Understand Context.

The Code is the Ultimate Truth

User-centric resolution, not platform-centric

*Platform-centric:
*

resolve(request) = platform.scope(request) // platform is the boundary
Enter fullscreen mode Exit fullscreen mode

.me-centric:

resolve(request) = me.graph(request) // user's graph is the boundary
Enter fullscreen mode Exit fullscreen mode

You don't declare schema for a platform. You declare:

me.whatever.you.want("x")
Enter fullscreen mode Exit fullscreen mode

And any surface that can resolve me://whatever.you.want — CLI, GUI, NRP mesh, another agent — can find it if it has audience.

This is Inverted Dependency Indexing + Namespace Resolution Protocol (NRP) — mesh-aware hop-by-hop resolution for me:// URIs, not DNS.

See: User Centric System and Centralize The Self, Distribute The Data

Stack: kernel, axioms, NRP, GUI

This is not another personal data store wrapper.

  • Personal semantic kernel: one value me that is both callable and infinitely chainable. typeof me === "function" and typeof me.profile.name === "function".
  • 10 axioms: Secret Root Stealth, Path-Bound Scopes, Noise Reset, Structural Pointers __/->, Query as Event ?, Tombstone -, Hash-chain integrity, LWW deterministic merge. All fire-tested: node tests/axioms.test.ts
  • NRP: Discover, score, forward, learn. Living network of monads.
  • Demos + GUI: neurons-me.github.io

Start here

If T ⊥ A clicked in one second because you suffer it:

  1. Read Axiom of Distinction — 3 axioms, 60 lines.
  2. Read Algebra of Encrypted Audiences — the mechanism.
  3. Clone .me, run me.security _ yourself. Break it.

me is not a platform to learn. It's a paradigm to resolve into.

world → .me → meaning

Top comments (0)