CLIP: A Protocol for the Chain of Custody of Information

The internet was built to move information. It was not necessarily built to tell us what that information meant. Email has SMTP. Web browsers have HTTP. The systems that move packets, messages, documents, and transactions across the network have accumulated protocols for identifying where things came from, who sent them, whether they were altered, and what should happen when something goes wrong. But we have comparatively little infrastructure for something more fundamental: What happens to a claim after we encounter it? That question is becoming increasingly important as the internet fills with journalism, scientific papers, government statements, corporate announcements, social-media posts, automatically generated content, propaganda, commentary, and increasingly sophisticated synthetic material. Arc Codex is an experiment in answering that question. And one idea emerging from that experiment is CLIP: the Claim Lifecycle & Integrity Protocol. We shouldn’t call it a Truth Protocol There is an important distinction here. When a system encounters a document on the internet, it generally does not know whether the document is true. It knows that someone has made an assertion. That distinction should survive the entire information pipeline. A university may publish a claim. A government may publish a claim. A newspaper may report a claim. A scientist may propose a claim. A corporation may announce a claim. A stranger on the internet may make a claim. The system should not silently transform any of those into truth merely because they arrived through a recognizable channel. Instead, it should preserve the history of the assertion. Who said it? Where did it originate? When was it published? What exactly was claimed? What evidence accompanied it? Who else reported it? What contradicts it? How was it classified? What interpretation was applied? Why did the system decide to amplify it? That is the territory CLIP is intended to occupy. Think of SMTP There is a useful analogy with email. SMTP does not determine whether an email is true. It moves messages. Around that basic transport system grew other mechanisms for establishing identity, authorization, integrity, and policy. SPF asks whether a server is authorized to send for a domain. DKIM provides a cryptographic signature. DMARC connects identity and policy. The result is not a magical truth machine. It is a system in which provenance and responsibility become visible. CLIP takes inspiration from that architecture and applies the idea to nonfiction information. Not: This statement is true. But: This statement entered the system here, from this source, at this time, carrying this assertion, and here is what happened to it afterward. That is a much more achievable—and arguably much more useful—promise. The claim needs a chain of custody Imagine a story entering Arc Codex. The process might look like this: Internet source ↓ Discovery ↓ Ingestion ↓ Source identification ↓ Claim extraction ↓ Ontology assignment ↓ Deduplication ↓ Cross-source comparison ↓ Evidence analysis ↓ NLP measurements ↓ Editorial routing ↓ Reporter ↓ Text-to-speech ↓ Broadcast Every transition can leave a record. That means the system can eventually answer a question that ordinary news aggregators rarely answer: Why did I hear this story? Not merely because an algorithm selected it. Because we can reconstruct the path. The queue becomes part of the evidence This is where an old systems-administration idea becomes surprisingly useful. Arc Codex can treat its ten editorial channels almost like traditional mail queues: Q0 Torchy Blane Q1 Sterling Quill Q2 Ada Sparks Q3 Penny Ledger Q4 Clara Bellwether Q5 Dr. Mercy Vale Q6 Jack Meridian Q7 Rex Nightingale Q8 Penny Press Q9 Milo Greenfield A story receives an identifier when it enters the system. That identifier follows it through ingestion, analysis, routing, narration, and publication. The audio file is therefore not the fundamental object. The story is. The MP3 is simply one representation of that story. This distinction becomes extraordinarily useful. The same story can have: * an original source document * extracted text * translations * analytical measurements * provenance information * a queue assignment * a reporter assignment * an audio rendering * a position in the current broadcast All of those can point back to the same underlying record. The filter log becomes an epistemic log A conventional mail system might record something like: QUEUE ID SENDER RECIPIENT DELIVERY STATUS An information system can record much more. For example: X=8F72A1 source=example.org discovered C=91D44E claim=extracted O=EXAMPLE-20260825 origin=identified N=SCIENCE.ENVIRONMENT V=+0.12 T=0.31 K=0.84 cluster=4A881 Q=Q9 reporter=MILO_GREENFIELD voice=bm_george Those numbers are not decorations. They become testable claims about the behavior of the system itself. If the software says it measures tone, the measurements should be recorded. If it says it measures constructiveness, those measurements should be recorded. If it says it categorizes sources, the classification should be recorded. If it says it deduplicates stories, the clustering decision should be recorded. If it says a story was routed to a particular correspondent, that routing should be recorded. Eventually, an auditor should be able to ask: Did the machine actually behave the way its designers said it behaved? That may be one of the most important questions an AI system can answer about itself. The system must be capable of catching itself This is the part I consider essential. It is not enough to build a system that claims to be unbiased. We should build a system capable of discovering evidence that it may not be unbiased. Suppose 2,200 sources are monitored. Perhaps 400 publish stories during a particular period. The system selects 100 for broadcast. Now compare the populations. Maybe technology stories constitute 15 percent of the incoming material but 35 percent of the broadcast. Maybe sources from one geographic region constitute 10 percent of the available material but 60 percent of what listeners hear. Maybe stories written in one language are systematically more likely to survive the translation and classification pipeline. Maybe one correspondent’s territory consistently receives twice as much airtime as another’s. Maybe one source is disproportionately represented because its stories are easier for the system to parse. Those are not necessarily errors. But they are anomalies worth investigating. The system should be able to say: Something about our behavior deserves examination. That is fundamentally different from claiming: Our algorithm is unbiased. The first statement can be tested. The second is largely a matter of faith. CLIP should record interpretation without pretending interpretation is fact There is another important boundary. A system can measure sentiment. It can estimate valence. It can classify tone. It can estimate constructiveness. It can identify rhetorical patterns. It can categorize an argument. But those measurements are themselves interpretations produced by a model. So they belong in the record alongside their provenance: Which algorithm? Which version? Which lexicon? Which model? Which configuration? When was it run? That allows the result to be reproduced, challenged, or replaced. A future version of the system might decide that an earlier classifier was systematically wrong. That should not require rewriting history. The original interpretation should remain available. The system should be able to say: This is what we believed then. and later: This is what we believe now, and here is why it changed. That is closer to science than to censorship. The ontology matters too A claim does not exist in a vacuum. It belongs somewhere in a conceptual structure. A climate story might involve: Climate → Energy → Agriculture → Economics → Government An AI story might involve: Artificial Intelligence → Technology → Labor → Regulation → Ethics A war story might involve: Geopolitics → Intelligence → Security → Economics → Humanitarian Affairs The ontology therefore becomes another part of the record. And because the ontology itself is authored by people, the ontology must be auditable too. Otherwise we merely hide our assumptions inside our categories. CLIP should eventually allow us to ask: Why did we put this story here? And then: Who decided that this category existed? That is where information architecture becomes epistemology. From origin to interpretation The larger ambition is therefore a complete chain: Origin → Claim → Evidence → Context → Classification → Interpretation → Distribution Each stage should be observable. Each stage should be logged. Each stage should be replaceable. And whenever possible, each stage should be independently testable. That gives us something much better than an opaque AI news filter. It gives us an auditable information pipeline. The modest promise CLIP should never promise: We know the truth. That would be absurd. Its promise should be much more modest: We will show you what we encountered, where it came from, what we did with it, and why it reached you. That is enough. Perhaps more than enough. Because when information becomes abundant, the scarce resource is no longer information itself. It is trustworthy process. We need systems that can tell us not only what they concluded, but how they arrived there. And when those systems discover that their own assumptions, classifications, measurements, or routing decisions have produced a distorted picture, they should be capable of showing us that too. That is the principle behind CLIP. Not a protocol for deciding what is true. A protocol for preserving the history of what we were told, what we did with it, and what we came to believe. And perhaps the most important rule of all: The system must be able to audit itself. Because if we build an instrument for stewarding the process of knowing, the first thing it must be willing to examine is the instrument itself.