OpenWyrd MOP — Manifesto

The primitive

A wyrd is a one-shot encrypted artifact. The author composes. The server returns a capability URL. The author shares the URL through whatever channel they choose. The recipient pastes it into a client and reads. The server holds ciphertext. The server never holds keys.

That is the whole primitive. Compose, capability, decrypt. One artifact, one URL, one read-cycle. TTL is set at creation — one day, ten days, ninety days, never. Replies are an explicit per-artifact bit, not an implicit social contract.

This is not novel cryptography. It is novel restraint. The discipline is in what we refuse to add.

Why standardize it

Encrypted messaging has been balkanized into walled apps for fifteen years. Each one holds the user, the contact list, the metadata, and the leverage. Each one calls itself private and means private from everyone except the platform. The capability-URL model breaks that pattern: the artifact travels independently of any account, any inbox, any relationship graph. It is a piece of ciphertext that knows how to be read, and nothing more.

Worth standardizing because the wire format is small enough to verify, the federation story is clean (any host can serve, any client can fetch), and the failure modes are bounded (lose the URL, lose the artifact — by design). A primitive at this scale either becomes a shared standard or fragments into a hundred incompatible silos. We are choosing the first.

Why federation

A messaging primitive that runs on one host is a hostage. A messaging primitive that runs on a hundred hosts, with a published wire spec and a conformance suite, is infrastructure. The capability URL is the federation seam — its shape is a contract between hosts and clients, not a property of any particular implementation. Any operator can stand up a host. Any client can read from any host. No single party owns the namespace, the keys, or the off-switch.

If the reference implementation disappears tomorrow, the spec survives, the conformance suite survives, the existing artifacts on every other host keep decrypting. That is the only acceptable shape for something touching encrypted communications.

Against the feed

The dominant communication architecture of the present decade is the feed: an optimization loop pointed at attention, owned by a counterparty whose interests diverge from yours by construction. Engagement is the metric, and the metric is the enemy. Every system that ranks, recommends, threads, or notifies is collecting on you and selling the collection back to itself.

OpenWyrd has no feed. There is nothing to scroll. There is no inbox. There is no badge count. There is no algorithm choosing which wyrd you see next, because there is no next — there is only the URL you were given, the artifact it points to, and your decision to open it or not. Attention is yours again because we built nothing to capture it.

The strong impulse, having built such a thing, is to add the conveniences back. We will not. The conveniences are how it dies.

What this is not

OpenWyrd MOP is not, and will not become:

• A chat app. No threads, no rooms, no presence. A wyrd is one artifact, not a conversation.
• An inbox. The protocol does not maintain a list of artifacts addressed to you. There is no recipient identity at the protocol layer.
• A social graph. There is no follow, no friend, no contact list, no directory. The protocol does not know who anyone is.
• A feed or timeline. No ranking, no recommendation, no discovery surface.
• A platform. Hosts are interchangeable. Clients are interchangeable. The brand on any one of them carries no weight at the protocol layer.
• A solution to every adjacent problem. Recipient-side rendering can leak. Third-party transport can leak. v1 is honest about what it does not solve.

The discipline

A primitive is judged by what it refuses. The work ahead is mostly the work of refusing — refusing the feature requests that would make it a chat app, refusing the partnerships that would make it a platform, refusing the convenience that would make it a surveillance instrument. Build the smallest thing that is correct. Standardize it. Then leave it alone.

Compose, capability, decrypt. That is the protocol. The rest is noise.