Architecture Deep-Dive

What this series is

The Learn articles make the case in plain language: agents have to share one current reality, you have to be able to see it, the record has to be trustworthy, and forgetting has to be deliberate. This series is for the engineers who then ask the obvious next question — how is that actually implemented without a central server?

Each deep-dive is a high-density technical treatment of one mechanism, written in the vocabulary you’d use when designing the system yourself: conflict-free replicated data types, vector clocks, anti-entropy, NAT traversal, Merkle proofs, tombstones, quorum. The goal is precision, not marketing.

How it maps to the Learn cluster

Every article here is the technical twin of a simpler one. “Single source of truth for agents” pairs with “CRDTs for conflict-free agent state.” “How independent agreement makes AI trustworthy” pairs with “Quorum and Byzantine-tolerant confidence.” The simple article links forward to the deep-dive; the deep-dive links back to the plain-English version. Read whichever altitude fits the question you’re holding.

The themes

The deep-dives group into the same problems the rest of the site circles: state (how many writers converge on one consistent view), transport (how peers reach each other directly and securely), integrity (how history is made tamper-evident and corroborated), and forgetting (how an append-only store still honors deletion). Different layers, one system: a shared, local-first memory your agents can read, write, verify, and trust — with your data staying on your own devices.

In this series

• WireGuard mesh and NAT traversal: how agents connect peer-to-peer across devices

  How peers on different networks reach each other directly and securely — using a WireGuard-style encrypted transport, a mesh overlay, NAT traversal via UDP hole punching, and relay fallback — without opening ports or trusting a central server.

• Tombstones and log compaction: deletion in an append-only store

  How a store that never mutates in place still supports removal, bounded storage, and a real right to be forgotten.

• Quorum and Byzantine-tolerant confidence: counting independent witnesses

  How a system decides how much to trust a claim by counting independent corroboration, why N copies of one source is not N witnesses, and why source independence — not raw vote count — is the hard part.

• The peer-to-peer sync protocol: gossip, anti-entropy, and delta exchange

  How replicas with no central server converge by gossiping, reconciling differences with a Merkle index, and shipping only the deltas each peer is missing.

• Merkle DAGs and content-addressed provenance: tamper-evident agent history

  How hash-linking turns an agent's history into a tamper-evident structure, lets two replicas verify they hold the same thing cheaply, and records who said what, when, and derived from what.

• Local-first vector search: embeddings and ANN retrieval on your own devices

  How semantic retrieval works on your own hardware — embeddings, vector similarity, and approximate nearest neighbor indexes like HNSW and IVF — without shipping your data to a hosted vector database.

• Event-sourced agent memory: deriving state from an append-only event stream

  How modeling agent memory as event sourcing makes the log of events the source of truth and treats every view of current knowledge as a derived projection you can rebuild or re-interpret at any time.

• CRDTs for agent state: conflict-free shared memory without a central server

  How conflict-free replicated data types let many agents read and write one shared state across machines, converging to the same result without locks, a coordinator, or a central database.

• Causal consistency and vector clocks: why agents read current, not stale, state

  How distributed systems track causality with logical clocks so an agent reads at a consistent cut and never acts on a value that has already been superseded.

• Append-only logs: immutable history with corrections, not deletes

  Why an append-only, immutable log is the right substrate for institutional memory: corrections become new records, history is never overwritten, and the whole chain stays tamper-evident.

• More in this series, coming soon.