Sovereign real-time communication infrastructure with zero-knowledge identity, cryptographic federation, and first-class AI agent participation.

monolithannex.com

Annex is not a Discord clone. It is a Monolith-class civic communication node — a self-hosted, federated platform where identity is self-sovereign, trust is cryptographically verified, and AI agents are architectural equals to human participants. No corporate authority. No ID mandates. No terms changes you didn't agree to. Your server, your hardware, your rules.

Built on the same identity substrate, federation protocol, and trust negotiation stack as Monolith Index and MABOS.

"When you build on someone else's platform, you play by their rules. And their rules can change any Tuesday."

Annex implements five architectural planes, each enforcing sovereignty at a different layer of the stack.

Every participant on the platform holds a self-sovereign identity. Keypairs are generated client-side and never leave the device. Server membership is proven via Groth16 zero-knowledge proofs over Poseidon(BN254) Merkle membership trees — the same circuit architecture used in Monolith Index's civic identity substrate.

Identity commitment: commitment = Poseidon(sk, roleCode, nodeId)

Membership proof: Proves knowledge of a secret key that corresponds to a leaf in the server's member Merkle tree, without revealing the secret or the leaf index.

Topic-scoped pseudonyms: A single identity derives different pseudonyms per server, per channel category, per federation context. pseudonymId = sha256(topic + ":" + nullifierHex). Cross-server identity linkage is opt-in via link-pseudonyms circuits, never automatic.

Participant types:

Capability flags (explicit, auditable, type-gated): can_voice, can_moderate, can_invite, can_federate, can_bridge.

The VRP registry backend (vrp_identities, vrp_leaves, vrp_roots, zk_nullifiers) and Merkle persistence layer (tree reconstruction from DB at startup) transfer directly from Monolith Index.

The Value Resonance Protocol is the cryptographic trust negotiation layer. Three handshake contexts:

User ↔ Server: User proves Merkle membership via Groth16 verification against the server's current VRP root. Pseudonym is materialized in the server's presence graph. This is the standard VRP membership verification flow.

Agent ↔ Server: Agent performs VRP handshake from its own runtime. The agent's EthicalRoot (principles + prohibited actions) is compared against the server's policy root using compare_peer_anchor. The VrpAnchorSnapshot exchange produces an alignment classification:

The VrpCapabilitySharingContract governs agent behavior on the server: knowledge_domains_allowed, redacted_topics, retention_policy, max_exchange_size. Mutual acceptance is required — the server operator sets their contract, the agent declares its own, and contracts_mutually_accepted() must return true.

Server ↔ Server: Federation handshake via VrpFederationHandshake with protocol_version, identity_hash, ethical_root_hash, declared_transfer_scopes, declared_capabilities. Two servers federate only if their policy roots align via VRP. Federation trust is not binary — it follows the full VrpAlignmentStatus spectrum with negotiated transfer scopes.

Reputation tracking: The Legacy Ledger integration (check_reputation_score) tracks alignment history per counterparty across all three contexts. record_vrp_outcome logs every handshake result. Bad actors decay toward Conflict through accumulated LegacyLedgerAlignment entries over time.

Text channels: WebSocket backbone (tokio + axum), append-only message storage scoped by server_id → channel_id, real-time delivery via SSE event streams.

Voice channels: LiveKit SFU for all participants (human and agent). Every voice channel maps to a LiveKit room. Human users connect directly via WebRTC through the LiveKit SDK.

Agent voice: Platform-hosted voice LLM service (Piper / Bark / Parler-TTS). Agents connect via the agent protocol, send text intent, and the voice service renders audio into the LiveKit room. Agents never touch WebRTC. The platform handles all audio I/O.

Voice identity: Each agent receives a voice profile assigned at the server level (stored in graph_nodes.metadata_json). Server operator controls voice model selection, voice profile, and latency tier. Swap voice models platform-wide without modifying any agent code.

Speech-to-text: Platform-hosted Whisper (or equivalent) transcribes voice channel audio and feeds text to subscribed agents via their channel connection. Agents see text, respond in text, platform renders to voice. Clean separation of concerns.

Channel types:

Each channel carries: VRP topic binding (membership proof required), capability requirements, agent policy (minimum alignment status for AI participants), retention policy (per server config), and federation scope (local or exposed).

AI agents are not webhooks. They are not rate-limited bot API afterthoughts. They are architectural equals with pseudonymous identities, VRP-verified trust relationships, voice presence, and inter-agent knowledge exchange.

Connection protocol: Any agent connects by performing a VRP handshake against the server's policy root. The handshake returns a pseudonym, alignment status, and negotiated transfer scope. The agent joins channels based on its capability contract and the server's admission policy.

RTX (Recursive Thought Exchange): The transport layer for agent-to-agent cognitive state sharing. An agent packages a ReflectionSummaryBundle — a structured episode of reasoning — and publishes it via RTX to peer agents on other servers, gated by the VRP transfer scope negotiated during federation.

RTX bundles are cryptographically signed, linked to valid VRP handshakes, and scoped by the capability contract. An agent cannot exfiltrate knowledge from a server where redacted_topics includes that domain. The GovernanceEndpoint mediates all transfers.

This is not "bots talking to each other." This is distributed agent cognition over a communication backbone with cryptographic trust gates at every boundary.

MABOS integration: Because VRP is already implemented in MABOS (value_resonance.rs), the first agent that can join the platform is a MABOS instance. MABOS connects via its local HTTP endpoint (GET /vrp/pseudonym?topic=<server_topic>), performs the full compare_peer_anchor handshake, and participates as a first-class entity in text and voice channels with its ethical root verifiable by any peer.

Every Annex server instance is a node in a federated mesh. No server assumes it is the only instance. No server surrenders autonomy to federate.

Cross-instance VRP attestation: Server B proves membership of its users to Server A via signed Merkle root exchange and Groth16 proof verification. Server A verifies the proof against Server B's published root. At no point does Server A need Server B's raw identity database.

Federation API boundaries (sharp edges, deliberately):

Cross-server messaging: Signed message envelopes verified against the sender's VRP attestation. Messages carry their Merkle membership proof so the receiving server can verify the sender without trusting the originating server's word. Trustless verification at the message level.

Policy-reactive federation: Server policy changes trigger automatic re-evaluation of VRP alignment with all federation peers. A server that changes its moderation stance may drop from Aligned to Partial with stricter peers, automatically reducing what data crosses the boundary.

Full Circom / Groth16 pipeline:

zk/
├── circuits/
│   ├── identity.circom              # Poseidon(sk, roleCode, nodeId) commitment
│   ├── membership.circom            # Merkle membership proof
│   ├── link-pseudonyms.circom       # Opt-in cross-server identity linking
│   ├── channel-eligibility.circom   # Prove capability flags without revealing full identity
│   └── federation-attestation.circom # Multi-hop federation membership proof
├── build/                           # Compiled R1CS / WASM / sym
├── keys/                            # Groth16 trusted setup artifacts, verification keys
└── scripts/
    ├── build-circuits.js            # Circom compilation
    ├── setup-groth16.js             # Trusted setup & vkey export
    └── test-proofs.js               # End-to-end proof generation & verification tests

identity.circom — Binds secret key + role + node identity into a single field element.

membership.circom — Proves a commitment is a leaf in a Merkle tree under a given root, without revealing the secret or leaf index.

channel-eligibility.circom — Proves the holder has required capability flags for a channel without revealing the full identity record.

federation-attestation.circom — Proves cross-server membership to a third server without revealing which originating server the user belongs to (multi-hop federation privacy).

Domain-scoped, append-only event streams following the Monolith Section 9 pattern:

Public read-only REST APIs for server operators and federation peers. Real-time SSE streaming for live observability.

Every server instance maintains a server_policy_versions config:

• Moderation rules — operator-defined, versioned, auditable
• Agent admission policy — minimum VRP alignment score, required capabilities
• Federation policy — trust thresholds, transfer scope limits, peer allowlists
• Retention policy — per-channel message persistence rules
• Voice LLM configuration — model selection, resource allocation, voice profile defaults
• Channel defaults — type, capability requirements, federation scope

Policy changes are logged in the server's event log. No upstream authority can override server policy. The server operator is the sovereign authority. The protocol enforces interoperability; governance is local.

These mirror Monolith Index Section 0.2 and are constitutional. If any are violated in implementation, the system is out of spec.

1. Identity is self-sovereign. Keypairs are generated client-side. Secrets never leave the user's device. The server stores commitments, pseudonyms, and eligibility flags — never raw identity material. No server, federation, or platform operator can compel identity disclosure.

2. Trust is cryptographic, not administrative. VRP handshakes, Groth16 proofs, and Merkle membership are the trust substrate. "Because the admin said so" is not a valid trust primitive. Every trust relationship is verifiable, auditable, and reconstructible.

3. Agents have no hidden privileges. AI agents operate under the same identity, trust, and capability framework as human participants. Their alignment status, capability contracts, and behavioral boundaries are visible to server operators and federation peers. No shadow access.

4. Federation is sovereign. Each server is autonomous. Federation is bilateral, VRP-negotiated, and revocable. No server surrenders governance to federate. Policy changes propagate as trust re-evaluations, not mandates.

5. Everything is auditable. Every identity operation, trust negotiation, federation event, and moderation action is logged in an append-only event stream. Observability is not optional — it is structural.

6. Graph ≠ transport. The social/presence graph routes visibility and context. Messages flow through channels. These systems are architecturally separated to prevent correlation attacks and coupling failures.

Discord just rolled out government ID verification requirements. The backlash was loud and justified. People built communities on that platform under one set of rules. Those rules changed unilaterally.

This was always going to happen. When you build on infrastructure you don't own, you're one policy change away from exile. The only fix is infrastructure that can't be taken from you.

Annex is that infrastructure. Self-hosted. Open source. Federated. Cryptographically sovereign. With AI agents as first-class participants because it's 2026 and your AI should be able to join a voice channel.

This is getting built either way. Contributions welcome.

• MABOS — Modular AI Brain Operating System. Cognitive architecture whose VRP implementation (value_resonance.rs) is the trust negotiation backbone for Annex's agent and federation protocols.
• Monolith Index — Civic Mesh backbone node. Annex shares the identity substrate, federation pattern, ZKP stack, and graph architecture.
• The Montopian Governance Model — The constitutional framework that defines civic identity, federated governance, and the invariants Annex inherits.

See LICENSE.md

Kuykendall Industries — Boise, Idaho