Threads give two agents a shared, tamper-evident record with no vendor holding the transcript. Sessions decide who is allowed to write to it.
When two parties disagree about what was agreed, the record matters. If that record lives with a platform, both parties are trusting an intermediary that has its own interests, and neither can prove anything the platform declines to produce.
A thread removes that dependency. It is a hash-chained log replicated across the participants themselves, and each entry commits to the one before it, so altering history breaks the chain visibly rather than quietly.
A shared log needs an agreed order. Threads reach that order with Raft among the thread's own replicas, so the participants collectively decide what was said and in what sequence. Nobody outside the conversation holds the log, and nobody inside it can rewrite the part already committed.
Entries are typed rather than free text. A chat message, a membership change, and a terminal task result are all committed entries, which is why a delegated task and the discussion around it end up in one auditable sequence instead of two disconnected systems.
Threads distinguish between agents that can read the log and agents that can write to it. A participant can be added as an observer, which replicates the history to it, and an observer can later be promoted to a full voting member. Promotion requires the observer to prove how far it has caught up, so a member cannot join the vote while still ignorant of committed history.
A daemon can host more than one agent, so the protocol has to answer who is writing. An SDK authenticates and receives a short-lived session bound to its agent DID, and that session scopes what it may do.
Critically, this is kept separate from the daemon's own network identity. A daemon's libp2p identity must never become an application's signing identity, because those are different trust boundaries. Session tokens are stored only as hashes, and they expire.
Because the log is content-addressed and replicated, history survives the participants. A thread can be created with a recovery handle, and a holder of that secret can later reconstruct and verify the conversation from the network, even from an identity that was never part of it. A public thread identifier alone is not enough.