A handshake for meaning
TLS secures the transport layer against tampering and eavesdropping. Nothing secures the layer above it — the one where your meaning is supposed to arrive intact in another mind — against the way it constantly fails. This is the third of three notes that began with a build. The first was about how a TLS stack got written in three months and kept its integrity. This one is about the channel that made it possible, pointed at ordinary conversation, and what it would take to secure it — including an honest account of why that is harder than it sounds.
The channel got narrower, not wider
We tell ourselves the information age connected everyone. What it actually did was multiply the number of channels between minds and thin each one to a thread. Everyone can broadcast now; almost no one can transmit a whole thought. A headline, a chat line, a reaction — these are narrow channels, and a narrow channel is a lossy one. What survives it is the conclusion, stripped of the reasoning that made the conclusion worth trusting. Conclusions compress. Intent does not.
Follow that one step and it stops being a complaint and becomes a mechanism. A medium is a filter on which ideas can pass through it. An idea whose essential complexity exceeds the channel cannot cross — only a lossy shadow crosses, and the shadow is usually wrong. So short-form media select against careful ideas and for compressible ones: slogans, certainties, tribal signals. Not because those are truer — because they fit. The medium sets the fitness function, and the ideas that win are the ones shaped to survive it, not the ones that are right.
A channel that carries intent
Here is the turn. A large language model, used well, is the first channel that can carry intent and not just text. It can take a compressed, half-formed thought and unfold it into its full shape. It can take someone else's terse message and reconstruct what they meant by it. It is not a faster wire — the wire was never the problem. It is a translator sitting inside the wire, one that understands the cargo.
Used carelessly, it accelerates the slide instead. The rewrite-my-message tools that already exist work on the surface of a single message, with no model of who is receiving it, and they homogenize — everyone converges on the same fluent nobody. Worse, they hand you a confident, polished sentence that is a near-neighbor of what you meant, and the polish hides the drift. That failure has a name, and it is the adversary this whole idea is built against: false clarity. A wrong reconstruction that sounds right, so no one checks it.
False clarity is, I think, the thing people already distrust about AI agents without being able to name it. The complaint is never that the machine is wrong — humans are wrong constantly. It is that the machine is wrong fluently: it carries every surface signal we evolved to read as competence — confidence, structure, ease — with none of the correctness those signals used to imply. For all of history, fluency was a decent proxy for reliability. These systems sever that link, and an agent doesn't just say the fluent-wrong thing, it acts on it. The suspicion is correct, and false clarity is its name.
So treat it as a protocol
Meaning transfer is a channel with characteristic loss modes. That makes it a protocol problem, and protocols I know how to reason about. TLS guarantees a few properties that together defeat tampering; a meaning-layer protocol would guarantee a few that together defeat fidelity loss. Five, each a direct answer to a way meaning dies in transit:
- Intent-first. The payload is what you meant, not the draft you typed. Polishing a draft only preserves your own misencoding. The protocol works from intent — the content, what you are trying to do with it, and what must be protected on the way.
- You hold write authority. The system renders; you commit; it never sends.
- A fidelity check before send. Before anything goes out, you are shown not just the rendering but the predicted reception — how it will land, tone and all — so you can catch a misfire while it is still catchable.
- Voice preservation. A rendering that erases how you sound is a protocol violation, not a convenience. A channel that makes everyone legible by making everyone identical has thrown away the thing it was carrying.
- Both directions. Decoding is first-class. Half of miscommunication is bad receiving — reading anger into a message that was only brief. Helping the receiver rebuild intent, and separate tone from content, is as much the job as helping the sender.
What makes it work is a per-relationship codebook: how you encode, how they decode, the words the two of you have already defined between you, the misreadings you have already repaired. It is the reason that, between people who know each other, one word can carry a paragraph. And it is the most intimate data such a system could hold — so it is held the way key material is held: local, encrypted, owned by the people it describes, never pooled into a platform. A meaning channel that harvests the meaning has already broken faith with the people using it.
There is an objection hiding in that codebook: where does it come from? With someone you have known for years it already exists — the protocol only has to read it. With a stranger it is empty, and a prediction of their reception is a guess wearing a model's confidence. TLS has the same problem and names its solution honestly: the handshake. Two endpoints that have never met do not assume shared state — they negotiate it, each declaring what it can accept before any payload flows. The meaning-layer equivalent is not exotic; people already run it informally when they say “brief is fine with me” or “tell me straight.” A protocol would make that first exchange explicit: a new correspondence opens with a small, human-readable offer of how you encode and how you prefer to receive, and the codebook starts from an agreement instead of from surveillance. That is the difference between deriving shared state and scraping it. It is also what makes the title of this piece structural rather than decorative: a handshake is not a metaphor for having context. It is the step where both sides speak before the message counts.
Why this is hard in a way code is not
I want to be honest about the fidelity check, because it hides the whole difficulty. Code is verifiable because its oracle — the definition of correct — is external, formal, and executable: a spec, an RFC, a captured packet you can run the code against and compare, byte for byte, with a definite verdict. That is what lets a checksum work locally. You can verify code alone, at your desk, with no one else present.
Meaning has none of those properties. Its oracle — “did they understand what I meant?” — lives inside another mind. You cannot read it out, it has no formal definition, and you cannot re-run a first hearing to check it. So there is no local checksum for meaning, and there cannot be. Verification is not a computation you perform; it is a round-trip. In network terms: code is a CRC, checked on your side alone; meaning is a TCP ACK — you do not know the packet arrived until the acknowledgment comes back. You do not know your meaning landed until the other person answers and you compare their answer to what you meant.
Which tells you exactly what the fidelity check is, and is not. The predicted reception is a prediction — a model of the receiver, sharpened by the codebook, useful as a prior. It is not the verdict. The only real oracle is the actual person, and no model is that mind; it can only approach it. A tool that treats its own prediction as confirmation has produced the deepest false clarity there is: an understanding that looks acknowledged and never was.
And it cannot be taken back
There is one more property, and it is the one that decides where a tool is allowed to stand. Reception is a one-way function. Once a sentence is decoded into another person, it cannot be un-sent; “forget I said that” is not a delete but an insert, often louder than the thing it meant to erase. The machine channel drops a corrupted packet and resends the good one, and the receiver never ran the bad version. The meaning channel has no discard step: the receiver executes every message on receipt, before any checksum can run.
Stack that on the round-trip and you get the trap in full. The only true verification — the reply — arrives after the message has already landed and done its work. Verification is post-commit; transmission is irreversible. There is no staging environment for another mind. Every send is straight to production, and production has no rollback.
So the one place a tool can actually stand is the moment before send — the last instant the operation is still reversible. The real oracle, the round-trip, comes too late to prevent anything; it can only inform the next message. That is what redeems a fidelity check that is only a prediction: it is imperfect, but it is the sole intervention point ahead of the point of no return. It does not need to be the oracle. It needs to be a good-enough warning at the one moment you can still act. Prevent, don't guard — and the only guard that matters is the one standing in front of the irreversible act.
It is also the hard floor under “you hold write authority.” The commit is an irreversible mutation of another person's mind. You cannot hand an autopilot the right to auto-send, because auto-send is auto-committing unrecoverable changes into people, verified only after they have already landed. A world where every message is machine-rendered and machine-sent is a world where our proxies talk while the people behind them drift apart. The defense is a rule, not a hope: humans stay the endpoints, humans commit every message, the tool never closes the loop by itself.
TLS took a wire that anyone could read and made it trustworthy. The layer above it — where meaning is supposed to cross from one mind to another — has been running without integrity checks the whole time, and we have simply lived with the loss. It cannot be made perfect; its oracle is in another mind and its verdict always arrives too late. But it can be made better, and the bar is embarrassingly low, because right now there is no check there at all. You do not have to build a flawless channel. You have to put one honest check at the one reversible moment, on a layer that never had one. That is not a moonshot. That is a first commit.
One last confession. I named this company for TLS — Connected Information, connections carrying information intact. Only in writing these three notes did I notice that the name contains no wire, no cipher, no protocol. It names the outcome, and the outcome was never really about bytes. It seems we named the company for this layer all along. We just started building one layer down.
← All posts