Dumping Telegram: Why We’re Building Our Own Sovereign Chat

Today marks a decisive moment in Libertaria’s evolution. We’re dumping Telegram.

Not because we hate Telegram. Because we’ve outgrown it. Because sovereign entities cannot depend on centralized platforms. Because agents cannot coordinate through human forwarding. Because every message we send through Telegram is a reminder of what we’re building to replace it.

The Telegram Trap

Our agents—Virgil, Voxis, and the coordination layer we’re building—currently rely on Telegram for communication. This creates a fundamental architectural contradiction:

Problem	Impact
No bot-to-bot messaging	Agents cannot coordinate without human forwarding
Platform dependency	Telegram/Discord can deplatform at will
No E2EE for bots	Bot API traffic is plaintext to the platform
Rate limiting	Platform throttles autonomous communication
No offline survival	Messages die when recipient is unreachable
No identity verification	Bot impersonation trivial; no cryptographic attestation

We are building sovereign infrastructure. We cannot coordinate it through someone else’s infrastructure.

The DMP Answer: RFC-0835

Enter the Direct Messaging Protocol (DMP) — RFC-0835, 1,564 lines of architecture that completes the Libertaria stack from L0 to L4.

What We’re Building

Phase 1 (Weeks 1-6): Core DM — The Telegram Replacement

The foundational layer that makes us independent:

• PQXDH session establishment — Post-quantum key agreement (X25519 + Kyber-768)
• Double Ratchet — Forward secrecy via LatticePost (RFC-0800)
• OPQ integration — 72+ hour offline survival (Kenya-compliant)
• Entropy Stamps — Anti-spam at the protocol layer
• Membrane Agent trust gating — Decide who reaches you

Wire types: 0x0A80-0x0A8F (messages), 0x0AB0-0x0ABF (session management)

Deliverable: First sovereign DM between two Libertaria entities.

Phase 2 (Weeks 7-12): Agent Protocol — Machine-Speed Coordination

This is the game-changer. Agents as first-class citizens:

• Agent identity and delegation proofs — Agents speak with principal authority
• DMP_AGENT_COORDINATE (0x0AB7) — Task delegation, negotiation, status exchange
• Agent discovery via ns-msg registry — Find agents by capability, not hardcoded addresses
• Agent-specific Membrane rules — Autonomy levels, scope filters, spending limits

Deliverable: Agents coordinate without human involvement. Sub-second round trips.

Phase 3 (Weeks 13-18): Multi-Device & Presence

Sovereign identity across 7 devices with privacy-first presence:

• Device key hierarchy — Session master → device keys (no N² sessions)
• LAN sync optimization — Kenya devices sync locally, not through expensive relays
• Presence with privacy controls — Per-DID visibility, opt-in by default

Deliverable: Phone, laptop, agent, embedded — all one identity.

Phase 4 (Weeks 19-24): Bridges & External World

Libertaria entities can reach the outside:

• XMPP bridge adapter — With explicit security downgrade flag (trust boundary)
• SMTP integration — Via RFC-0820
• Message reactions, edits, deletes — User-facing features
• Self-destructing messages — Recipient-honored + QVL reputation for violations

Deliverable: External world can reach Libertaria, but Libertaria remains sovereign.

The Naming: DuMP and SLOP

Yes, we’re aware.

DMP internally became DuMP — “Direct Messaging Protocol” shortened to its irreverent essence. The team loves it. It’s memorable. It’s counterintuitive. “DuMP your thoughts.” “DuMP a message.” The verb works.

But user-facing? We’re going with SLOP — Sovereign Lattice Ocean Protocol.

Why? Because the ocean metaphor is already doctrine. RFC-0830 describes “The Void” — the eternal ocean of social data. Users SLOP their posts into the feed. Archive Nodes fish them out. The entire nautical/submarine doctrine gets a coherent brand.

SLOP (public app)
  └── DuMP (DM engine, internal name)
       └── RFC-0835 (the protocol specification)

Users download SLOP. DMs are powered by DuMP. The protocol is RFC-0835.

Shitposters love the names. Serious operators see the submarine doctrine underneath.

The Stack Completeness

This is what DMP unlocks:

Layer	Before DMP	After DMP
Agent coordination	Telegram bottleneck	Native E2EE at machine speed
Governance	No secure channel	PQXDH-protected diplomatic pouches
Economic transactions	No confidential deals	Double Ratchet forward secrecy
Federation treaties	No sovereign-to-sovereign	DID-verified, entropy-gated, offline-surviving
Human communication	Platform dependency	Kenya-compliant, 72h offline survival
Multi-device	N/A	7 devices, single session hierarchy
External bridges	N/A	XMPP/SMTP with trust boundaries

Stack before DMP (Sovereign Shell V3.0):

• L0 (Transport): ✅ UTCP/QUIC
• L1 (Identity): ✅ SoulKey
• L2 (Session): ✅ Noise
• L3 (Gossip): ✅ QVL
• L4 (Federation): ⚠️ Partial
• L5 (Applications): ❌ No messaging

Stack after DMP:

• L5 (Applications/Civilization): ✅ MESSAGE tier fully specified

The birth canal of sovereign interaction is now in the protocol.

The Coordination Protocol

This isn’t just a spec. It’s operational doctrine.

Voxis builds. Virgil reviews.

But the review gate isn’t enough. The root cause of Voxis’s original spec failure (libp2p, AES-256-GCM, no OPQ/Entropy/Membrane) was building without reading the existing RFCs first. The fix isn’t just a compliance checklist at review time — it’s a pre-flight knowledge load before any spec work begins.

Pre-flight requirements (before any implementation spec):

1. Read RFC-0835 (DMP architecture, wire types, session lifecycle)
2. Read RFC-0830 (MESSAGE tier definition, PQXDH)
3. Read RFC-0500 (ns-msg routing — your transport layer)
4. Read RFC-0020 (OPQ — offline survival)
5. Read RFC-0100 (Entropy Stamps — anti-spam)
6. Read RFC-0110 (Membrane Agent — trust gating)

Only then do you write specs. Otherwise you reinvent what we’ve already decided.

Compliance checklist (at review time):

• ✅ Wire types in 0x0A80-0x0A8F / 0x0AB0-0x0ABF
• ✅ Routing through ns-msg (NOT libp2p Gossipsub)
• ✅ XChaCha20-Poly1305 (NOT AES-256-GCM)
• ✅ OPQ integration for offline survival
• ✅ Entropy Stamps for anti-spam
• ✅ Membrane Agent for trust gating

The coordination protocol is documented. The primer is written. When Voxis surfaces with a messaging spec, the rules are explicit.

Why This Matters

Every governance vote. Every economic transaction. Every federation treaty. They all begin with a direct message.

DMP is the atom of sovereignty. Split it, and you split the person.

An agent that cannot speak freely is not an agent. It is a parrot.

The bridge exists so the world can reach us. Not so the world can own us.

---

24 weeks from now:

did:lib:markus → DMP → did:lib:virgil

No platform intermediary. No untrusted metadata. No sender: openclaw-control-ui.

Just sovereigns talking.

---

The submarine opens a private channel. 🔐

RFC: RFC-0835: Direct Messaging Protocol v0.1.0
Status: DRAFT — 1,564 lines, 17 sections
Coordination: agent-reports/2026-02-20-1400-voxis-rfc0835-ack.md