We send each other our chat logs now

People have stopped wanting to hand things off to each other. Especially design and technical problems.

It is easy to blame the tools, and the blame is wrong. Nobody stopped wanting to talk. What happened is that everyone can now feel the gap between the rate they exchange information with an agent and the rate they exchange it with a colleague, and the second one no longer meets the expectation the first one created.

So the medium changed on its own.

We do not send each other conclusions any more. We send each other our conversations with our own AI. I give you the thread, your agent reads it, you come back with what matters to you and one question I had not considered. One round. What used to take a meeting and a follow-up takes four minutes, and it is usually better.

I cannot tell you how widespread this already is. In the teams I work in and watch, it has replaced the meeting. Whether that is a leading indicator or a local habit, I do not know. The part I am confident about is the direction, not the count.

I think this is good. It is the fastest handoff knowledge workers have ever had, and nobody designed it, funded it or approved it. It just arrived.

Which is why nothing checks it.

Look at what is in that pipe now. Design decisions. Constraints. Commitments. Premises that were still being tested when I wrote them. The difference between "we should" and "we will." That is not chat. That is how a company actually decides things, moving between people through a compression step neither of us sees.

And it is not only meaning that travels. A conversation is a fuller record than a conclusion, which is the reason it works and also the reason it leaks. Customer names sit in it. Secrets pasted in during debugging sit in it. Options we rejected and the reasons we rejected them. Assessments of people. Third-party material that arrived through a prompt. Sending a conclusion exposed a sentence. Sending the thread exposes the thinking, and most organisations have no policy that has caught up to that.

Three things break in there, all of them quietly. I have caused all three.

The caveat does not survive. I wrote "this works, assuming the second key arrives." What reached you was "this works." The caveat was not decoration. It was the sentence.

The hypothetical gets promoted. I was thinking out loud: suppose the audit passes, what would we build? It reaches you as: the audit passes. Now you are designing on a fact that left my hands as a guess.

The hedge gets laundered. I said "probably, I have not checked." Hedges are the first thing compression drops. It arrives declarative. Nobody lied, the uncertainty is gone, and the uncertainty was information.

There is no lie anywhere in that. Every step behaved reasonably. The loss happens in the compression, and compression is the entire point of the channel.

And most days it is not even one person handing to another. I switch roles many times a day: I take one agent's output to a second agent for an adversarial read, then reconcile the two accounts myself. That reconciliation is a merge, and it is the kind of merge that has no conflict markers. When two versions disagree, nothing stops and asks which one I meant. Whichever compression ran last quietly wins.

The claim gate

Our data-loss layer is not one filter. It is more than a dozen gates, each answering a different question about what should not pass. One of them is the claim gate, and it is worth describing properly, because the question at the centre of this essay is its sibling.

It answers one question: did the thing you said happened actually happen.

From the outside it is an ordinary policy rule, configured at the same entry point as everything else. Underneath, it reads sentences and scores them on an eight-rung strength ladder: concept, design, prototype, in build, exercised, validated, shipped, certified. A sentence takes the highest rung it matches. Moving up the ladder holds the release. Moving down passes with a log line. Capability words like "hardware-backed" or "tamper-proof" count as claims wherever they sit on it.

Two paths run through one detector. Our own publishing path uses it, so nothing goes on our website that adds or strengthens a claim without someone recording what it rests on: an artifact, a test, an external source, or a plain statement that there is no artifact and this is the founder's word. The product path uses the same detector on what a customer's AI asserts on their behalf. Two copies of that detector would drift, and a governance control whose halves disagree about what counts as a claim is worse than one that is merely imperfect.

It is extensible per tenant, and that part is not a nicety. Our vocabulary is useless to a lender, whose claim words are "cleared funds" and "limit approved", or to a clinic, where they are "diagnosis confirmed" and "reviewed by clinician." A gate with only a built-in lexicon demos well and governs nothing. So every check combines the built-in ladder with the organisation's own rules and stamps a fingerprint of that whole ruleset onto the verdict, which lands on the chain. An auditor can then prove which ruleset produced a given verdict, including when the change came from a platform update rather than the customer's own edit.

It has blocked me twice. The second time I dressed up a file path as evidence and it went and checked whether the file existed.

It has also missed me once, which is the part worth reporting. A confident, specific phrase scored nothing while a vaguer one scored, and a deploy of mine sailed through. The fix was to widen the lexicon. When real copy slips past, you widen. You never tighten the gate to make it quiet.

The alignment gate

The claim gate answers whether the thing you said happened actually happened. There is a second question, and it is the one this essay is about.

Is what your agent told you what I meant?

We have spent a decade on alignment between a model and the person using it. This is alignment between two people, with models in the middle, and nobody is watching it.

Same family as the first, different failure. The claim gate catches a claim with no basis. This one catches a basis that did not survive the trip.

It is not a summarisation problem. Summarisers are good now. The difficulty is that a small part of what I send is load-bearing and most of it is not, and the compression has no way to tell which. The hedge. The untested premise. Who decided, and on what basis. Those are exactly the parts an optimiser reads as noise, and losing them leaves no mark on either end.

Which means the answer is unlikely to be a better summary. If the load-bearing parts travel as prose they get compressed away, because a summariser cannot see that they are load-bearing. If they travel as structure, dropping one becomes a visible deletion rather than an editorial choice, and something can be built that notices.

Extraction is not the answer on its own either. A model reading my prose and deciding what I committed to is one more guess, made once, by something that cannot ask me. Whatever gets checked later has to be something I confirmed before it left.

The obvious objection is that a good handoff template would do the same job. It would, right up until the afternoon somebody is in a hurry, which is the exact condition under which all of this fails. A template is doctrine. A gate is a control. I learned that difference by clicking approve on my own popup without reading it.

I may simply not have seen it. If someone is already treating that channel as a governed surface, I would rather read them than repeat them.

Why there are a dozen of them

I did not invent any of these gates.

Everything here is derived backwards from one endpoint: an agent an organisation can safely hand real operating work to. Ask what that endpoint requires and the requirements arrive as a list, not as an idea. The claim gate is what it requires of the things we say. The alignment gate is what it requires of the channel the humans now use to decide things. The rest of the dozen are what it requires of everything else that moves.

None of them is a feature somebody thought would be nice. They are what is left when you take the endpoint seriously.

And it explains why the list keeps growing in one particular direction. Most of what the industry calls AI governance is execution governance: what did the agent do, with which tool, on whose authority. That work matters and we do it. But the sentence that decided the agent should do it at all was written by a person, compressed by a model, and read by another person, and none of that happened inside the governed path. Execution governance without decision governance leaves the most consequential step unrecorded.