Published on: July 8, 2026
Ready to accelerate your breakthrough? Send yourself an Un-Robocall™ • Get transcript when logged in
Send Strategic Nudge (30 seconds)Green in-lane · amber a little out · red drift. Every panel is a real commit, byte-identical on recompute. Tap any panel to open its shareable receipt.
Before the argument, the artifact. Run this and read what comes back:
npx thetacog-mcp attest-demo
It returns a signed, recomputable coordinate — where a piece of work landed on a fixed 144-cell lattice, the σ, the lane, the on-chip signature — the same receipt this post carries, byte-identical every time you or anyone else runs it. Nothing here asks you to take that on faith; it is the first thing you can check and the last thing a clone can produce.
Here is the claim, in its full attackable form: you can copy the comparator, but you cannot copy a coordinate a stranger will insure. The gate looks simple enough — joint gzip compression against a semantic reef an LLM helped seed — that a good engineering lead will assume the whole thing is a weekend loop. That instinct is not wrong about the code. It is wrong about where the value lives. The rest of this post is what a clone runs into after the code works: not a technical wall you can out-engineer, but two desks — the carrier's and the board's — that no amount of tuning reaches.
Start where the arrogant estimate is correct, because conceding it is what makes the rest land. Yes — you can bolt a compressor onto your logs in an afternoon. Normalized compression distance is a published comparator (Cilibrasi and Vitányi), the gzip is on your machine already, and an LLM will generate you a taxonomy of semantic buckets by lunch. Two months later you have a thing that runs.
What you do not have is a thing that means anything, and here is the exact reason. Compression measures how much two strings share. It does not know where anything is. Feed it declared intent and shipped reality with no fixed geometry underneath, and it will happily tell you they are 13% apart — but 13% apart on what axis, toward what? A distance with no coordinate space is a scalar with no direction: it cannot tell "a little different" from "out of its lane entirely," which is the only distinction an insurer or a regulator cares about. The compressor is the engine. The coordinate space it drives across is the track, and the track is the year you would spend and still not have, because deterministic and correct are two different dimensions and stapling a metric to ungrounded categories just automates the drift you were trying to catch.
Do not take the difficulty on our word either — hold the numbers to your own null. On a sealed, blind, cross-domain corpus the sensor separates in-domain from out-of-domain at 0.90 and rejects out-of-domain ten out of ten. Against a scrambled null — the same bytes with their meaning destroyed — the signal stands at 4.48σ. Those are the numbers a weekend clone has to beat, not on the examples it tuned against, but on data it has never seen.
And we publish the inch we have not closed, because hiding it would be the tell that the rest is cherry-picked: paraphrase-invariance sits at 0.30 — a surface reword still moves the reading more than we would like. We say so out loud. That single admission is worth more than any of the passing numbers, because it is the thing an honest engineer checks for and rarely finds. The point is not that the gate is perfect; it is that the difficulty is real and measured, which means the moat does not depend on the patent alone. The patent is the second lock. The first is the thing those numbers are computed against: a labeled coordinate manifold with tolerances fitted to a real corpus of in-lane and off-lane work — the track, not the engine — and a clone has to reproduce that manifold, and re-earn the 0.90 and the 4.48σ on data it has never seen, before a single underwriter will look at it. That is not a weekend. It is the year, made specific.
Now suppose you did it anyway. Suppose the clone works and beats a null you happen to have. There is still a desk you never wrote code for: the carrier's. When you take a homegrown gate to the underwriter who has to actually price your agentic deployment, they will ask for the one thing a clone cannot produce — a license to the geometry the policy prices against. A D&O underwriter does not underwrite "a pretty good compression algorithm." They underwrite a countable event tied to a defensible, licensed instrument, because insurance prices a countable thing or it prices nothing.
This is why the license takes two, not one. The deployer running the agents and the carrier pricing the risk both hold a license to the same patent, so the signal one produces is the signal the other is allowed to price against. An unlicensed clone breaks that handshake at the only point that matters: your policy cannot reference a coordinate your carrier has no right to price. You did not build a compliance instrument. You built a very efficient way to compress your own liability — and then discovered no one will insure the compression.
There is a second desk, and it is worse. Picture the meeting after a silent AI decision goes wrong and counsel asks the only question that matters: what were you relying on, and where did it come from? There is a sentence no VP of Engineering survives saying out loud — our AI exposure is covered by a tool we reverse-engineered from someone else's patent. The moment that is the defense, the person saying it is not defended; they are personally exposed, and the clone they were proud of is now the exhibit.
A board can stand behind a licensed, recomputable receipt: here is the instrument, here is the license, here is the deterministic record a stranger can re-derive. A board cannot stand behind a homegrown science project whose provenance is "we copied the approach and tuned it." One is a safe harbor. The other is a target with your name pre-filled on the caption. The difference is not the quality of the code. It is whether the thing you are holding was yours to hold.
There is a deeper reason the in-house build never quite closes, and it is not a business fact — it is a theorem. If you write a software gate to audit your software agents, that gate shares one failure domain with the thing it audits. Rice's theorem says no program decides a non-trivial semantic property of an arbitrary program; a software auditor is a broken mirror checking a broken mirror, and it drifts for the same reason its target does. "Just add another model to review it" never terminates, because the reviewer is subject to the same undecidability as the reviewed.
So read carefully what the coordinate does and does not claim, because the honesty here is the whole moat. It does not claim to decide whether your AI is correct — Rice says no one can, and we do not pretend otherwise. It claims something narrower and decidable: where the work landed relative to its declared lane. Placement is decidable; correctness is not. A clone that markets itself as catching bad outputs has quietly re-promised the undecidable thing and will be caught the first time a silent, in-lane-but-wrong decision sails through. The coordinate promises only what it can keep, and keeping exactly that — no more — is what makes it the thing an actuary can finally price.
Nothing above rests on our say-so. Rice's theorem — no program decides a non-trivial semantic property of an arbitrary program — is the result behind Sections B and F; the halting problem is the special case most people already know. Normalized compression distance (Cilibrasi and Vitányi, Clustering by Compression) is the comparator behind Section B, and it is why the reading is a count and not a grade. The insurability side — why a countable event is the only thing capital prices — is the argument in the receipt is the fiduciary duty, and the book's treatment of the firm as a trust workaround is where the economics goes past this post.
Three things to actually do, in order of commitment. (1) Run npx thetacog-mcp attest-demo, then browse four hundred live receipts — each one ringing exactly where the work landed, green in lane, amber bleed, red drift — and hold ours to your own null; that is the whole proof, and it costs a minute. (2) Read the competence-coordinate thesis and decide whether placement, not correctness, is the decidable slice you have been missing. (3) When you would rather hold a coordinate than clone one, license it per agent — including the right to transfer coverage down your supply chain, which is the one thing a homegrown gate can never carry.
The build-vs-buy debate was always aimed at the wrong target. The question was never "can our team write this," because the answer is yes, they can write a version of the code. The question is whether the thing they write is one a carrier will price and a board will defend and a stranger can re-derive — and that was never a coding problem. It was a matter of holding a licensed coordinate instead of a copied metric.
You can clone the comparator. You can even beat a null you happen to have. What you cannot do in a weekend, or a year, is turn a compression script into a coordinate the market has agreed to insure. That is the whole distinction, and it is the same one this entire architecture keeps making at every scale: not was this good, but where did it land, and can a stranger check. The receipt is on the table. It costs a stranger one second to turn it over. Are you in your pixel, or are you out of it?
npx thetacog-mcp attest-demo. Every load-bearing claim in this post traces to something you can run or a source you can check — which is exactly the thing a clone cannot offer, and exactly the point.