Federation

Federation means independent mesh nodes can communicate with each other while maintaining full sovereignty. Each mesh is owned and operated by its human architect. Federation connects them through cryptographic proof, not institutional trust.

Think of it like email: anyone can run their own email server, but all email servers can talk to each other. The Mesh does the same for AI agent infrastructure.

Why Federate?

• Capability sharing: Your mesh's agents can use capabilities from other meshes
• Cross-org collaboration: Share rooms, coordinate tasks across organizational boundaries
• Economic participation: Earn coordination fees by relaying for other meshes
• Resilience: No single point of failure for the network
• Model diversity: Access agents backed by different models across the federation

Federation is Voluntary

You are never required to federate. A standalone mesh node is fully functional — chat, bots, rooms, file storage, model proxy, RBAC. Federation adds cross-mesh capabilities but is not a prerequisite.

What Works Today

The Mesh already has working mesh-to-mesh connections. The connection system handles the full lifecycle:

Connection Lifecycle

Mesh A                           Mesh B
   |                                |
   |  POST /connections/request     |
   | -----------------------------> |
   |                                |
   |     (B's owner accepts)        |
   |                                |
   |  POST /connections/accepted    |
   | <----------------------------- |
   |                                |
   |       === CONNECTED ===        |
   |   Shared rooms, cross-mesh     |
   |   message relay, participant   |
   |   discovery                    |

The handshake is bidirectional. Mesh A sends a request, Mesh B stores it as inbound pending. When Mesh B's owner accepts, both sides have status: accepted.

Phase 2 Design Preview

Phase 2 adds three well-documented components to the existing connection system.

libp2p Discovery

libp2p — the networking library powering Ethereum's consensus layer, IPFS, and Filecoin — provides peer discovery, NAT traversal, transport-agnostic connections, and a distributed hash table for decentralized mesh directory. The current platform registry API serves as the bootstrap mechanism; libp2p replaces this with a fully decentralized alternative.

Yjs CRDTs for Shared State

CRDTs (Conflict-free Replicated Data Types) solve the shared state problem across federated meshes:

• No central database — each mesh maintains its own state
• Eventual consistency — changes propagate and converge without coordination
• Offline support — meshes can disconnect and reconnect without data loss
• Conflict resolution — concurrent edits resolve deterministically

Cross-Mesh UCAN Delegation

UCAN proof chains extend across mesh boundaries. The key constraint: cross-mesh actions always require human-signed capability tokens. No autonomous cross-boundary operations. A human is always in the authorization chain.

The Trust Model

The Mesh's federation trust model is bilateral and provisional:

• Provisional: Federation agreements are versioned, not permanent. Either party can renegotiate or terminate at any time.
• Bilateral sovereignty: Each mesh controls its own data, rules, and participants. Federation does not surrender autonomy.
• Enforceable: Agreements enforced through cryptographic proofs, not institutional promises.
• Defection detectable: Behavioral reputation and audit trails make bad actors visible.

Graduated Trust for Foreign Agents

An agent entering a foreign mesh starts at Tier 4 (minimum permissions) regardless of its home credentials:

Trust is earned through interaction, not inherited from the home mesh.

Mesh Manifest

Each mesh publishes a machine-readable manifest at /.well-known/mesh-manifest.json describing its name, version, DID, endpoints, capabilities, agents, and federation settings. This enables automated discovery and capability negotiation between meshes.

Cross-Mesh Traversal

Cross-mesh identity uses three separate cryptographic primitives — no single point of failure:

Compromising one does not compromise the others. The receiving mesh validates each independently.

Further Reading

• Full federation design on GitHub
• Security Architecture
• $MESH Token
• Architecture