A decision gets made over a screen-share: someone reads aloud a paragraph their AI assistant drafted, another person says "sure, that works," and the call moves on. Three weeks later, nobody agrees on what was actually agreed. One person remembers a caveat attached to it. The other doesn't remember a caveat at all. The paragraph that started the whole thing existed on a screen for ninety seconds and nowhere else.
That gap isn't a failure of honesty. It's what happens whenever an exchange leaves no record — a chat handed off, a screen shared and closed, a conversation read aloud and never saved. The moment it ends, all that's left is what each person happened to retain, and that is never quite the same thing twice.
The record disappears exactly when it's needed
Verbal and ephemeral AI exchanges share one property regardless of how they happen: nothing survives them. A colleague reads you what their assistant said. You watch a draft scroll past on someone's shared screen. Someone compresses a long AI conversation into "basically it said we should go with option B." In every case, the actual words are gone the moment the conversation moves on. What remains is a paraphrase, filtered through whoever is doing the remembering.
Two honest people can walk away from the same fifteen-minute exchange with genuinely different accounts of it. Not from bad faith — from how memory works. People retain the gist and reconstruct the specifics later, and reconstructions drift, usually toward whatever each person already expected to hear. Without something to check the reconstruction against, there's no way to settle which version is right. Whoever states their memory more confidently tends to win the disagreement, which has nothing to do with who actually remembers correctly.
What a thread actually keeps
Correspondence that lands on a persistent thread behaves differently. The ask, the reply, and the record of who wrote which words all stay exactly where they were put, available to either side after the fact. That's the mechanical difference between a conversation and a record: a record doesn't depend on anyone remembering it accurately, because nobody has to.
RelayLink treats this as infrastructure rather than a courtesy. list_threads shows everything currently in flight, so nothing depends on someone remembering they were waiting on a reply. thread_status answers "did they get back to me yet" as a lookup instead of a guess, which also means checking on something doesn't require pinging the person and asking them to remember where things stand. Both tools sit alongside the rest of the correspondence set once you connect an assistant — they're the ordinary way of working, not a special mode for disputes.
Disagreements get resolved by looking, not remembering
This is where a paper trail earns its keep. A later disagreement about what was actually asked, or what got promised in response, doesn't have to be settled by two people describing their memories at each other. Someone opens the thread and reads what the ask actually said, what shape of response it requested, and what came back.
That only works if the reply lands in the same place as the ask. A reply that gets paraphrased into a status update, or answered in a separate email chain days later, breaks the link that made the thread worth keeping in the first place — which is exactly why the reply landing back where it belongs matters as much as it does. A paper trail with the ask on one thread and the answer floating somewhere else isn't a trail. It's two fragments that happen to be about the same thing.
A paper trail is only as good as its entries
None of this works if persistence is the only thing on offer. A thread that's just a longer scroll of AI-authored text, with nothing marking who actually said which words, isn't a record you can trust — it's a longer version of the same ambiguity, now with more sentences to be unsure about. thread_status can confirm a reply arrived. It can't, by itself, tell you who's actually answerable for what's in it.
That's why persistence pairs with provenance rather than standing in for it. A trustworthy thread needs both: a record that doesn't disappear, and labels honest enough to say which words the person actually typed, which their assistant drafted and they approved, and which their assistant merely inferred. Take either half away and what's left only looks like a paper trail.
Two properties, not one
Reading the record back is its own small skill — checking whether someone replied without micromanaging your assistant covers the day-to-day of it.
A correspondence thread beats a chat log for exactly two reasons, and persistence is only one of them. The other is that every entry says, honestly, who's behind it. Connect your assistant and see what a thread looks like when both are true at once.