cankun.me

The Cairn Whitebook: An Anti-Laundering Substrate for AI-for-Science

Jun 18, 2026
A weathered cairn of visibly scarred stones stands where several faint trails converge
A weathered cairn of visibly scarred stones stands where several faint trails converge · View full resolution

About this piece. This is the v0.1 design whitebook for Cairn. It records the full argument for why an early-stage project is shaped the way it is, not a stable product manual — the design is still evolving, and the trade-offs here may be overturned by later versions. I have kept the narrative parts of the original whitebook (Parts I–IV and the case-study appendix NK) and dropped the purely reference-grade runbook (Part V).

Thesis. A cairn is a trail marker that earlier travelers built, one stone at a time, on the open ground. It does not walk for you, and it does not judge which path leads where; it simply stands there, stubbornly, so that whoever comes next knows someone passed through and the way runs this direction. The Cairn this book describes is the digital version of the same thing: a deterministic, judgment-free, anti-laundering substrate. It durably captures the judgments an AI agent makes during scientific analysis into portable documents and mechanically enforces that those judgments stay consistent with one another — but it never itself interprets, never counts paths, never averages, never returns a verdict. Its only reason to exist is to resist laundering: to make sure a conclusion, as it climbs upward from artifact to claim to summary to project conclusion, retold across different agents and across months of time, always carries its scars with it — which fork it is conditioned on, what refuted it, whether it has gone stale, whether anything independent ever verified it. Keep the scars alive, rather than letting the conclusion be washed into a clean, good-looking, false result.

Contents

  • Part I — The Problem (Epistemology)
    • I.1 The verifier asymmetry: algorithms are commodities, verifiers are scarce
    • I.2 Biology queries a black box (software is a white box)
    • I.3 Canonical ≠ Verified: the consensus axis and the truth axis are orthogonal
    • I.4 The garden of forking paths and the multiverse: robust ≠ true
    • I.5 Anti-laundering as a first principle: a precise definition of laundering
  • Part II — The Answer (Why this shape)
    • II.1 A judgment-free deterministic substrate + judgment to the agent: forced by the bitter lesson
    • II.2 Durable capture: let judgment be inherited, not re-derived every time
    • II.3 Parasitize, don't reinvent: OKF owns format, bytes by reference + fingerprint, Cairn adds only the resistance layer
    • II.4 Express, don't resolve: every residue carries a deflation pointer
  • Part III — The Mechanism (How it works)
    • III.1 Three OKF node types: claim / estimand / confound, and why "handle vs narrative" isn't redundant
    • III.2 Estimand as a first-class node: body is the definition, id is the identity, the CLI compares ids not semantics
    • III.3 Trust axes that never merge + five deterministic gates
    • III.4 Distrust the writer: asserter / reviewed_by / derived corroboration
    • III.5 Freshness derived from fingerprints; CLI verbs, Skill axioms, OKF bundle layout
  • Part IV — Boundaries and Falsification
    • IV.1 The front-stage epistemology: what is a multiverse good for, anyway?
    • IV.2 The permanent ceiling: consistency is not truth
    • IV.3 The falsification test: maybe you don't need to build a system at all
    • IV.4 The map of prior art: you are not unique
    • IV.5 What it doesn't solve: drawing Cairn's no-go lines explicitly
    • IV.6 A sub-narrative seriously considered, then abandoned: E/N/U
  • Appendix NK — The full case study (anonymized)

Part I — The Problem (Epistemology)

This part only erects the problem. What shape Cairn takes, and why that shape, is left to Part II; the mechanisms and their point-by-point links back to the ADRs are left to Part III. The goal here is to push "why an anti-laundering substrate is needed" to the point of epistemic inescapability: any reader — including an AI session that just woke up with no context — should be able to independently reconstruct this judgment rather than be asked to believe it.

I.1 The verifier asymmetry: algorithms are commodities, verifiers are scarce

A verifier is a mechanism that can decide "is this answer right?" cheaply, quickly, and deterministically. In software engineering it is everywhere: unit tests, type checks, CI (continuous integration — the pipeline that automatically reruns every check on every change). You write a sort function, run the tests, red means wrong and green means right. The decision itself costs almost nothing in money or time, and whoever runs it, however many times, gets the same answer. This kind of decision is the invisible bedrock that lets software be industrialized, automated, and pushed forward in parallel by countless agents.

Science has no such bedrock.

Algorithms are commodities; verifiers are scarce. In a domain with a cheap verifier, you can safely automate "generating candidate answers" to a frenzy: however much garbage you generate, the verifier can cheaply, after the fact, scoop out the right ones and throw away the wrong ones. Generation is cheap because filtering is cheap. The algorithm (the generating half) thus becomes a commodity — anyone can run it, and the more the better. What is genuinely scarce, what actually decides whether a domain can be scaled up, is the other half: the verifier that can tell you which candidate is right.

Software has that verifier, so it can be written at scale by agents — wrong code gets caught by tests and CI and cannot be laundered into the trunk. Science, biology especially, does not have that verifier, or rather its verifier is extraordinarily expensive, extraordinarily slow, and often simply nonexistent. There is no line of test that can run "is this differential-expression conclusion actually reflecting biology?" It either needs a new wet-lab experiment, an independent patient cohort, a flow-cytometry validation (expensive, slow, sometimes impossible), or — more commonly — there is no in-system means whatsoever to decide it.

This asymmetry is the starting point of the whole book, and it has a direct, brutal corollary: the "generate at scale + filter cheaply" paradigm that works in software degrades, when carried into science, into "generate at scale + no filter." When you put a fleet of AI agents into a domain with no cheap verifier and let them generate tens of thousands of analytic conclusions, you do not get tens of thousands of verified findings; you get tens of thousands of conclusions that sound right, with no cheap mechanism to separate "sounds right" from "is right." This is not a matter of agents not being strong enough; it is a structural fact about the domain: optimizing for "looks right" where there is no verifier produces plausibility, and plausibility is not truth.

So the question is not "how do we build a scientific verifier." This book's position is that, for computational analysis, that verifier is permanently scarce and often absent — a fact to be respected, not a defect to be papered over by tooling (Part IV confronts it head-on as a permanent ceiling). The question is the other side: since there is no cheap verifier to filter out false conclusions, a "sounds right" conclusion, as it climbs all the way from artifact to paper, must at least not quietly wash away its honest scars — which path it depends on, what refuted it, whether anything independent ever checked it. The verifier asymmetry is precisely the origin of the "anti-laundering" need.

I.2 Biology queries a black box (software is a white box)

Why does biology have no cheap verifier? Because the object it studies and the object software studies are not the same kind of thing epistemically — and that difference is the root of the asymmetry above.

Software is a white box. Its "truth" is the source code: behavior is fully determined by readable, deterministic rules. If you want to know how a function will behave, you can in principle read its code, single-step its execution, and have it reproduce the exact same output on the exact same input. State is directly readable, rules are simple and stable, execution is deterministic and replayable. The verifier is cheap in software precisely because of these white-box properties: to decide "right or wrong," you have a deterministic reference frame to check against directly.

Biology faces a black box, and a very particular kind of black box. Break its four properties apart and you can see exactly why a verifier here is expensive to the point of near-nonexistence:

  1. No source code. There is no readable "list of rules" that determines how a cell will behave. You cannot "read the code"; you can only infer, from external behavior, an internal mechanism you can never directly confirm.
  2. You can only perturb, never read state directly. You cannot directly read a cell's "true state" right now; you can only poke it (add a drug, knock out a gene, sequence it) and see how it responds. All knowledge of the interior is inferred indirectly from the response to a perturbation.
  3. The return value is mediated by a noisy measurement apparatus. What you get is never the state itself, but the state after passing through a layer of noisy, biased, artifact-prone measurement instrumentation. In single-cell sequencing, sequencing depth, dropout (shallow sequencing causing some genes to be read as 0), and library-prep method are all distortions the apparatus inserts between you and the truth. The "signal" you see is part biology, part instrument.
  4. No promise of simple, stable rules. This black box is under no obligation to be compressible into a clean set of laws. It can be highly context-dependent, chaotic, sensitive to initial conditions. Even if some regularity exists, there is no guarantee it is simple, nor that it holds stably across samples or conditions.

Put these four together and "why the verifier is expensive" becomes obvious: to decide whether a conclusion is "right," you need a reference frame independent of your current measurement-and-analysis system, and every one of this black box's properties raises the cost of obtaining such a frame. You cannot read the source code (no source), you can only poke again (expensive perturbation), what you poke out is still an instrument-distorted reading (noisy mediation), and you cannot assume "this poke will cleanly reproduce the last one" (no stable-rule guarantee). "Independent verification" means going back to the black box and poking again from as uncorrelated an angle as possible: a new wet-lab experiment, an independent cohort. It is expensive and scarce, ultimately, because the black box does not let you cheaply confirm any assertion about its interior.

In the single-cell immunology vignette that runs through this book (see Appendix NK; here it only anchors the intuition), the reason "the more deeply sequenced group appears to have many up-regulated genes" is so deadly is exactly black-box property 3 at work: the "up-regulation" you see might be biology, or it might be purely an artifact the apparatus (deeper sequencing vs. shallower) manufactured between you and the truth — and the black box will not volunteer which. In software you could read the source to tell true from false; here you cannot, you can only go back to the box and poke from another angle (precisely what triangulation does later), and that is expensive.

I.3 Canonical ≠ Verified: the consensus axis and the truth axis are orthogonal

Here we introduce the book's most easily confused, and most crucial, distinction. They are two different words pointing at two orthogonal things, and the book never lets them merge.

  • Canonical (adopted as the current standard) refers to the status of a conclusion being deemed by a community (a lab, a field, a paper's coauthors) as "the current standard practice / the official version / the one everyone uses." It is about consensus: how many have adopted it, whether it has been written into the workflow, whether it is treated as the default starting point.
  • Verified (independently verified) refers to a conclusion having passed a check independent of your current analysis system, and being confirmed to correspond to reality. It is about truth: the conclusion has been poked from another angle on the territory (a wet-lab experiment, an independent cohort, clinical follow-up) and held up.

These two axes are orthogonal — not two points on one line, but two different dimensions. Draw them as a 2D grid and you see the most dangerous, most common cell: a conclusion can be canonical (everyone adopts it, it's in the paper, it's the default) yet never verified (no check independent of the analysis system has ever confirmed it). The moment one of your computational-analysis conclusions is written into a paper, it usually sits in this cell: it is canonical (the coauthors accepted it), but far from verified (no wet lab ever answered back). The vast majority of computational-analysis conclusions live their whole lives in this cell, and that is fine in itself; what is wrong is the act of treating this cell as verified.

Why must the two axes be kept apart, and never allowed to merge? Because merging them is precisely what opens the door to laundering. The book treats the two axes asymmetrically: for computational analysis, the verified axis is almost always empty — the vast majority of conclusions will never get a wet-lab confirmation. An always-empty axis looks deletable, but precisely because it is always empty, it must exist. It is a warning light that almost never lights up, whose only job is to occupy the "verified" slot, so that no canonical conclusion can quietly slide in, and nothing can pretend to be lit where it was never genuinely lit. The longer it sits empty, the more important it is as a structured marker of the fact "this has not yet been verified." And in the rare moment when clinic or wet lab truly confirms a conclusion, it lights up once, recording that one moment that actually touched the territory.

This says, for the first time and precisely, what "laundering" looks like in this vocabulary, as a lead-in to the next section's full definition: laundering is, in a place that only earns the canonical mark, quietly treating it as verified. Consensus impersonating truth.

I.4 The garden of forking paths and the multiverse: robust ≠ true

The previous section was about a single conclusion being impersonated as true. But the threat has a more structural source, one that occurs before the conclusion is produced, in the choice of analysis path itself.

The garden of forking paths (Gelman & Loken 2013) — in plain terms: facing the same data, the researcher has at every analysis step multiple choices that all look reasonable (how to normalize, which cell-annotation set, which statistical test...), and which one they pick is usually pulled along by the data itself: only after seeing a number that looks off do they go back and try another route. The single path they finally report is just one of many paths that "could equally have been reported"; precisely because the choices are data-contingent, even if there was no subjective cheating at all (no p-hacking), the reported path has already been "selected" by the data. The garden metaphor: every step has a fork, the trail you walked out looks like the only natural one, but behind it lies an entire garden of paths you did not walk — and did not even remember you could have.

Multiverse analysis (Steegen et al. 2016) — in plain terms: rather than report only the one path you happened to walk out, run all the reasonable paths and see whether the conclusion holds across the whole garden. Each reasonable combination of settings is a "universe"; run them all and you get a multiverse; you no longer look at the number in some one universe, but at the distribution of the conclusion across all universes.

Ground it in the anonymized single-cell immunology vignette (full narrative in Appendix NK). Setup: in a single-cell immune dataset, compare two patient groups (group A, group B), running differential expression (DEG — finding genes whose expression differs significantly between the two groups) on some immune cell type. When you run the garden of "normalization method × how to handle the sequencing-depth difference × which statistical test" — six each-reasonable setting combinations — the number of significant DEGs swings from about 80 to about 1200, and even "which is the top up-regulated gene" flips back and forth between a real signal and a technical artifact. The most naive path (the software default) happens to be the worst: it crowns a housekeeping gene expressed in nearly every cell as the top up-regulated gene, which is purely a technical artifact caused by the shallow-sequencing group reading it as 0.

This vignette teaches three things, each fed directly into the book's design:

First, the silent default is the most hidden fork. On that worst software-default path, the researcher does not even realize they are forking, because the software chose the default for them. Where the garden of forking paths really buries its bodies is not in the steps where you vigilantly compared several approaches, but in the default steps you accepted from the outset, never doubted, and therefore never folded into the multiverse (this is pushed to its limit in I.5 and in Appendix NK's "honest corrections").

Second, the multiverse's real payoff is not the number on any single path, but the invariant. Run the whole garden, and the most trustworthy output is the signals that stably survive under every reasonable setting. In this vignette, it is the up-regulation of a set of activation/interferon signatures and the down-regulation of a cytotoxic marker, which do not vanish as you swap normalizations or tests. What is worth reporting is not some cherry-picked path, but the manifold robust across the whole garden. The multiverse is not nihilistically declaring "everything is arbitrary"; on the contrary, it runs off the arbitrary part so the robust part can show itself.

Third, and most important and most easily botched by tooling: robust ≠ true. The multiverse damps researcher degrees of freedom; it gives you confidence about "does the conclusion still hold if I analyze differently." But it cannot fix a confound in the experimental design. In this vignette there is a wall no analysis can cross: group A's samples are sequenced more deeply and use a different library-prep method (pooled vs. per-sample), and "sequencing depth / library prep" is fully collinear with "group." This is not a fork you can walk differently; it is a flaw in the design itself, and no normalization, no test, can pry it apart. So even a signal robust across the whole garden may still be driven by this confound rather than by the biology of the group. Robustness is about "robust to analysis choices"; it lives on the canonical axis; however high it climbs, it never touches the verified axis, which only the territory (a different experimental design, an independent cohort) can answer. Treating "robust across all paths" as "already verified true" is exactly the laundering act of I.3, translated into the multiverse context.

This draws, for a responsible tool, the boundary of what it can and cannot do: it can and should help you retain the information attached to a conclusion — which path I'm conditioned on, whether I have a contradictory sibling path, how robust I am across the whole garden; it must never settle the multiverse on your behalf into a "robust therefore probably true" verdict, because that verdict is itself robustness impersonating truth — laundering. (This boundary is exactly the design motive for "express, don't settle" in Parts II and III, and exactly the warning issued by the multiverse authors themselves, cited in Part IV.)

I.5 Anti-laundering as a first principle: a precise definition of laundering

The previous four sections were four independent pressure points: the verifier is scarce (I.1), the object is a black box (I.2), consensus impersonating truth (I.3), robustness impersonating truth (I.4). They converge onto a single word, and that word is Cairn's reason to exist — its first principle.

The precise definition of laundering: as a conclusion passes upward from one layer to the next — from artifact, to claim (an evidence-bearing analytic conclusion), to summary, to the writeup for some immune cell type, to the whole paper's project conclusion — each layer quietly drops a little of what is necessary to keep the conclusion honest: which path it is conditioned on, which sibling conclusion refuted it, whether it has gone stale, whether anything independent of the analysis system ever verified it. With each layer dropped, the conclusion becomes a notch cleaner, prettier, more certain. By the time it reaches the top, it is a clean, beautiful, false result: all the scars washed off, leaving a single sentence that sounds beyond question. Laundering requires no one to lie; it is the natural entropy-increasing direction of information under layer upon layer of retelling, summarizing, and "for readability" compression. Summaries naturally tend to drop conditions, papers naturally tend to drop contradictions, and someone newly taking over (or a new AI session) naturally tends to treat the canonical they read as established fact. No one acts maliciously, and yet the conclusion is laundered the whole way up.

Translate the previous four sections into the language of laundering and you see they are four facets of one thing:

  • Because there is no cheap verifier (I.1), no cheap automatic mechanism stops a conclusion from being laundered. In software, CI stops it; in science there is no CI, and laundering goes unobstructed.
  • Because the object is a black box (I.2), the things being washed off — is this a measurement artifact, is this path robust, was the confound pried apart — are exactly the things the black box will not volunteer and that have to be laboriously poked out and laboriously remembered. They are the most expensive, so they are the most easily omitted in retelling.
  • Canonical taken for verified (I.3) and robust taken for true (I.4) are the same laundering act landing on the "consensus–truth" and "path–truth" axes respectively.

So anti-laundering is Cairn's first principle: not a feature, but the sole reason Cairn exists, the axiom prior to every mechanism choice. Stated positively: a conclusion, on its upward chain artifact → claim → summary → cell-type writeup → project conclusion, retold across different agents and across months of time, must always carry its scars — which fork it is conditioned on, what refuted it, whether it has gone stale, whether anything independent verified it. Keep the scars alive, rather than letting the conclusion be washed into a clean, good-looking, false result.

This principle also delimits what Cairn does not do. Saying this in the problem section is necessary, lest Cairn be misread as yet another "tool that judges right from wrong for you," which is exactly what it refuses to be. Anti-laundering does not judge a conclusion true or false for you (the verifier is scarce; it has no such ability and will not fake one), does not settle the multiverse into a verdict for you (that is robustness impersonating truth, the very laundering it guards against), does not light up verified for you (only the territory can answer). It does exactly one thing: at every layer of retelling, mechanically and deterministically refuse to let those scars be quietly dropped. Who gets judgment, who gets mechanism, why this shape — that is Part II's business. The problem section stands here: in a domain with no cheap verifier, whose object is a black box, where both consensus and robustness are easily impersonated as truth, conclusions get laundered layer by layer into clean fakes; keeping a conclusion alive to the top with its scars intact is the first-order need.

Part II — The Answer (Why this shape)

The target Part I set is clear: on the upward chain artifact → claim → summary → project conclusion, conclusions get laundered layer by layer. Laundering means stripping off the things that keep a conclusion honest — which fork it is conditioned on, what refuted it, whether it has gone stale, whether anything independent verified it — leaving only a clean, good-looking finished product. And the verifier (a checker that can mechanically decide "right/wrong") is mostly absent in black-box-querying work like biological analysis: you almost never have a machine that can tell you "is this differential-expression conclusion true?" Part I also gave two sharper assertions: canonical (the version adopted as the current standard) ≠ verified (independently confirmed by something outside the analysis system); and the garden of forking paths and multiverse analysis tell us robust ≠ true.

Part II answers not "what to do" but "why Cairn must be shaped the way it is, and not some other way." Four load-bearing walls, each a rejection of a tempting but wrong alternative design.

II.1 A judgment-free deterministic substrate + judgment to the agent: forced by the bitter lesson

The most natural — and most dangerous — design impulse is to weld "judgment" into the tool. Since we have a garden of forking paths, a multiverse, it seems only reasonable to write a tool that adjudicates it for us: count how many paths agree, average the effect sizes, hand out a "robustness score," and declare "five of six paths agree, so it's probably true." This is precisely the use the multiverse authors themselves repeatedly warn against. Rohrer, Hullman & Gelman (2026, What's a multiverse good for anyway?) and Del Giudice & Gangestad (2021) argue: a tool that mechanically interprets the multiverse — counting agreeing paths, averaging, translating "robust" into "probably true" — manufactures "a guise of rigor and completeness," and fails as a serious inferential tool. We are not borrowing their authority to endorse Cairn; on the contrary, they are the ones who drew the ground Cairn must not step onto (Part IV fully unpacks this "diagnosis, not permission" relationship).

There is a second, more engineering-flavored reason this line cannot be crossed: the bitter lesson (Rich Sutton's observation — in the long run, methods that lean on general computation, search, and learning always beat methods that hand-encode human domain knowledge into the system; the latter is appealing short-term and gets steamrolled by compute long-term). Hard-coding judgments like "are these two paths answering the same question?", "is this fork genuinely arbitrary, or is one setting clearly better grounded?", "what would deflate this uncertainty?" into if statements and counters in a CLI is a textbook bitter-lesson anti-pattern: you have frozen a set of human heuristics in a place that a reasoning system ought to be reasoning about. In multiverse analysis these judgments further depend heavily on domain knowledge and statistical understanding (which is also why Del Giudice & Gangestad's E/N/U trichotomy is hard to land in practice and why the "uncertain" bucket would be the norm; see Part IV). Weld it in and the tool ages fast alongside that 2021 framework; whereas a capable agent will not only use such a framework but surpass it.

So Cairn's first load-bearing wall is a clean cut: the tool does no interpretation (judgment) whatsoever; it does only mechanism that can be completed deterministically without understanding content.

A recurring misreading must be corrected here: this line divides interpretation vs. mechanism, not "human vs. tool" — it is not "humans judge, machines execute." An AI agent is itself a reasoner. The gravity Rohrer et al. warn against is "do not replace reasoning with mechanism," not "do not let AI reason." So judgment belongs to the reasoning layer, and in Cairn the reasoning layer is mostly the AI agent itself:

  • Interpretation → to the agent (axioms baked into a Skill, not the CLI): Are these two siblings the same estimand (the estimand being what quantity a claim measures, in which population, conditioned on what)? Is this fork genuinely arbitrary or is one setting more defensible? What is the possibility set? What would deflate this residual uncertainty? What does a contradiction mean? These are reasoned by the agent using its own understanding plus context grabbed on the spot.
  • Mechanism → to the CLI (hand-written, deterministic, who-agnostic — same treatment regardless of who wrote it): fingerprints and freshness; graph-structure validation of reach-ground (every claim, walking up its dependency edges, eventually lands on a real artifact/file/dataset/external reference); consistency gates on declared labels (e.g., refusing to merge siblings that declare different estimands); persisting judgments as OKF and logging history; and refusing structurally illegal writes.

Hence the CLI never produces a verdict, because a verdict is interpretation. The "convergence engine / robustness scorer" that appeared in an earlier design — which would resolve the multiverse into a trustworthy verdict — is deleted outright, because it is exactly the use the multiverse authors say fails, and exactly the bitter-lesson anti-pattern. The CLI stays small: it fingerprints, validates the graph, opens gates against declared labels, and stores — but never counts, never averages, never scores, never infers. All the intelligence is on the agent side; the tool does only what can be "verified without understanding."

The cost must be written honestly on the wall: this buys a permanent ceiling — the CLI enforces "consistent with what was declared," never "what was declared is true." An agent can still launder by mis-declaration, e.g., labeling two genuinely-different-estimand paths with the same id so they merge. The later writer-distrust axis and independent review narrow this, but never close it. This is a boundary inherent in the shape, and Part IV unpacks it specifically.

II.2 Durable capture: let judgment be inherited, not re-derived every time

The second load-bearing wall answers a question that seems unrelated to the first but is in fact the same at root: where should judgment live?

The tempting cheap answer is "living in the Skill prompt is enough; no storage needed." It is rejected, on the grounds of the time dimension of Part I's laundering chain: judgment that lives only in some session evaporates. If every fresh session (a brand-new agent session that reads the canonical head to get oriented quickly) re-derives from the raw context, it will re-commit the same mistake — and re-derivation is precisely the mechanism by which a wrong conclusion "comes back to life." A fork that was refuted gets walked again by the next agent, the original refutation already forgotten, and so the wrong conclusion hardens once more into a "closed/negative" conclusion.

So durable capture is not an add-on feature of Cairn; it is the substrate's reason to exist. The shape:

  • Every claim is durably persisted as OKF — a frontmatter handle plus a body narrative. The body holds the reasoning; the frontmatter holds "the state the next agent / the CLI can act on without rereading the prose." This handle is the anti-re-derivation device: the next session reads the handle and directly inherits "this is contested, unresolved," without having to reason from scratch and step into the same pit again.
  • Both sides of a contradiction are persisted; neither may be dropped. A correction produces a version (written into log.md), never a silent overwrite — an overwritten refutation is as good as never having existed.
  • The orient surface (head / index.md, the canonical face an agent reads at the start) must surface unresolved contradictions and staleness explicitly up front, rather than burying them under a pile of canonical positive conclusions. A buried refutation is a laundered refutation.

This wall and the first are interlocking: judgment belongs to the agent (wall one), so judgment must be passable across agents and across time (wall two). Without wall two, "judgment to the agent" degrades into "judgment to this current agent," reset and re-laundered with every session swap.

II.3 Parasitize, don't reinvent: OKF owns format, bytes by reference + fingerprint, Cairn adds only the resistance layer

The third load-bearing wall is a principle of restraint, and also a self-critique of v1. Cairn v1 invented its own storage format, its own viewer, and ended up having to indefinitely maintain a format and a frontend it did not own, while drifting in its late design toward that convergence engine that would resolve the multiverse. The v2 correction: parasitize on existing wheels that do it better, and add only the one layer of "resistance" no one else does.

The division of labor is clean:

  • OKF owns the format, the container, the viewer. A claim is an OKF concept file (markdown + YAML frontmatter). Estimands and confounds (a confound being a design flaw that analysis itself cannot pry apart) are OKF nodes, referenced by claims via id. A published snapshot is a portable OKF bundle, rendered by the standard OKF visualizer — collaborators install nothing, and the bytes never leave the page. The timeline is written as OKF-native log.md, not a Cairn invention.
  • Bytes by reference + fingerprint, never ingested. Artifacts (result tables, model objects, figures) stay where they already are — gitignored, on external volumes, or on remote hosts; Cairn stores only their path reference and fingerprint, never ingesting bytes into the store and never versioning bytes itself (ADR 0003). The git footprint is always text-only; a multi-GB project still produces only a few hundred KB of claim text. The fingerprint's source is tiered (ADR 0002): the content hash of a pipeline tool (e.g., targets) is top-tier (rigorous, and computed for free as a side effect of its own memoization), a direct hash of a stray result file is mid-tier, and unknown when the remote is unreachable. When a content-addressed tool (e.g., DVC) is present and an artifact has a stable content-hash pointer, the CLI reads that hash as a top-tier fingerprint source; this is just "one more high-quality fingerprint source when it's present," not a second load-bearing leg Cairn parasitizes on.
  • Cairn adds only the resistance layer. It stores no bytes, invents no format, writes no viewer. What it adds is the one layer neither OKF nor the underlying byte storage will do for you: fingerprint-driven freshness, reach-ground validation, anti-laundering consistency gates, territory-locked verification, and the derived corroboration axis. This layer, and only this layer, is Cairn's own.

This principle likewise interlocks with the spirit of the bitter lesson: don't spend engineering effort reinventing general infrastructure; save it for that small patch of "resistance logic no one else did and someone must."

II.4 Express, don't resolve: every residue carries a deflation pointer

The fourth load-bearing wall is Cairn's posture toward uncertainty itself, and also its sharpest dividing line from the rejected convergence engine.

The convergence engine wants to resolve: flatten the multiverse's uncertainty into a clean, trustworthy verdict. Cairn's posture borrows Rohrer's exact words: "embrace uncertainty, don't resolve it." The value of the multiverse is not in handing you a final answer, but in keeping those conditions, those disagreements, those "no one has independently checked this yet" faithfully on the table. A tool that resolves uncertainty away is itself a laundering machine: it washes "across six reasonable settings, the DEG count drifts from about 80 to about 1200" into a single clean number. What Cairn does is keep a conclusion carrying its qualifications and unresolved disagreements as it travels upward, across agents, across time.

This posture is mechanized into a few deterministic gates, each of which "expresses" rather than "resolves":

  • A claim must declare which fork it is conditioned on (depends_on_fork, e.g., normalization=log1pPF) — the fork is expressed, not flattened.
  • A claim may declare that it contradicts another — disagreement is recorded structurally, not buried in prose.
  • A claim still carrying an unresolved contradiction is kept out of settled — a contested conclusion may never harden into "closed/negative." This is exactly the gate that mechanically blocks that real failure case (a forgotten contradictory fork letting a wrong "closed negative" conclusion harden into the final conclusion).
  • An ineradicable confound can be inherited by id (inherits_caveat), so the design flaw propagates along graph edges to every downstream claim, rather than being copied once and then lost.

But if "express, don't resolve" stopped here, it would leave a real hole: a system that only hoards uncertainty and never points to an exit is itself a dereliction. So every residual uncertainty must carry a deflation-route pointer (deflation_route), spelling out what it would take to remove that uncertainty. There are only three classes of exit:

  1. Clarify the estimand — this "uncertainty" may exist only because two paths are answering different questions; make the estimand explicit and it vanishes.
  2. Do more validation — e.g., donor-level pseudobulk (aggregate many cells per donor into one pseudo-bulk sample before comparing, to avoid treating cells from the same donor as independent samples; full definition in NK.5), per-donor consistency, cross-cell-type lineage logic — such triangulation can lift "possibly true" to "more credible."
  3. Change the experimental design — when the confound is collinear with the grouping and no analysis can pry it apart (this is a design flaw, not a fork), the only exit is a new design.

There is an inviolable red line here that fully separates deflation_route from the deleted convergence engine: Cairn points the way, but never walks it for you. deflation_route is a pointer, not an adjudication. It will say "this uncertainty should be shrunk by running a donor-level pseudobulk," but it will not run it itself, nor declare the conclusion established once it has been run. Walking that path, judging the result, deciding whether the uncertainty was truly shrunk — that is the agent's (reasoning layer's) job, the job wall one assigned to the interpretation side. The tool's only responsibility is to ensure this exit is honestly recorded on the claim and not laundered away upward.

This also connects back to the never-closeable ceiling: after deflation, you may have lifted a conclusion from "possibly true" to "more credible," but robust ≠ causal ≠ verified. However much triangulation you do, as long as the design flaw of confound-collinear-with-grouping remains, the treatment/batch effect can never be separated from the biology — that needs exit (3), a new design, not anything the tool's internal computation can give you. Cairn faithfully carries this residue and its deflation pointer all the way up; where it cannot reach verified, it honestly marks that it cannot.

These four walls together are the engineering shape of Part I's first principle (anti-laundering): judgment belongs to the agent and must be durably inheritable (walls one and two), the format parasitizes on OKF and bytes are referenced by path + tiered fingerprint and never ingested (wall three), and Cairn itself contributes only the one layer of resistance that lets qualifications and disagreements survive — express don't resolve, point the way don't walk it (wall four). Part III unpacks the concrete mechanisms of this resistance layer one by one, linking each back to its own ADR: why estimand is a handle while E/N/U does not become a field, why verification is territory-locked, why freshness is decided by fingerprint and not by process, why the writer is distrusted.

Part III — The Mechanism (How it works)

The previous two parts answered "why such a thing is needed" and "why this shape." This part lands the shape at the mechanical level: what parts Cairn is built from, what each does and does not do, and how each mechanism links back to the epistemic principle it serves. The dividing line Part II drew holds throughout: judgment to the agent (the reasoner), mechanism to the tool (the deterministic substrate). Every part below answers the same question: can this be done deterministically without understanding content? If yes, it goes in the tool; if no, it is left to the agent. This line divides interpretation from mechanism, not human from tool — an AI agent is equally a reasoner. This part demonstrates section by section where the line falls.

III.1 Three OKF node types: claim / estimand / confound, and why "handle vs narrative" isn't redundant

OKF is the carrier Cairn parasitizes on — treat it here as a "concept file" format: one markdown file per concept, with a YAML frontmatter (structured key-value pairs) at the top and free-form body prose below. Cairn invents no storage format of its own; it writes judgments as OKF files and adds only the "resistance" layer on top of that format. Cairn uses three node types:

  • claim: an analytic conclusion. E.g., "on some immune cell type, a housekeeping gene H is significantly up-regulated in group A relative to group B."
  • estimand: which question a claim is actually answering — which effect you measure, in which population, conditioned on what. "The true biological differential expression of H in group A vs. group B on that cell type" is one estimand; "the apparent fold change of H under the current normalization" is another. Same gene, two different questions.
  • confound: a design flaw that analysis cannot remove. E.g., "sequencing depth ≡ group ≡ library-prep method, all fully collinear." It carries an unerasable flag, marking that this is not a path-choice issue but a dead knot in the data itself.

Estimand and confound are made independent first-class nodes, referenced by claims via id, rather than copied into each claim's text, because this is the first line of defense for Part I's anti-laundering at the data-structure level. A confound copied as a string scattered through the bodies of twenty claims will be omitted in the twenty-first — this is Latour's "black-boxing": a fact that originally bore scars, washed into a clean conclusion through layer upon layer of retelling. Make it instead a node with a single definition plus an inherits_caveat reference edge, and the confound's propagation becomes one edge on a graph, not a string copy; it has a single source of truth, and every downstream claim that references it mechanically inherits it — no one can wash it off.

Inside a claim there is a subtler, more underrated design: frontmatter is the handle, body is the narrative, and the two may not duplicate each other verbatim (ADR 0004).

  • The body (narrative) is for humans and for "drill-in to read closely" agents: the conclusion together with its conditions, contradictions, caveats, and "what would change it," explained in prose. This is the reasoning itself.
  • The frontmatter (handle) is for machines to scan: only machine-actionable state — this claim's estimand id, which fork it is conditioned on, who it contradicts, which confound it inherits, its provenance (source class), and a set of locked fields the CLI computes and stamps on (see below).

Insisting on "no duplication" is not fastidiousness but the only way reasoning at scale doesn't explode. Imagine a fleet of agents ran hundreds or thousands of forks, leaving hundreds of claims, and a new session comes in to orient. If actionable state like "is this claim still valid, who does it contradict, which question does it belong to" is buried in the prose, the new agent must reread every claim's body to get it. ADR 0004 names this act re-derivation, which is precisely the mechanism by which a mistake comes back to life: a refuted fork is walked again, its original refutation long forgotten. The handle is the anti-re-derivation device — the new agent scans all the frontmatter (cheap, O(n), each one small) to get the global picture, and drills into only the few bodies genuinely worth examining. Scan all handles, read few bodies: only then does reasoning cost grow boundedly with scale, instead of every new session rereading the whole garden. The handle carries state, the narrative carries reasons, each doing its own job without duplication — this is the physical realization of ADR 0004's principle: judgment is persisted and inherited by the next session, not re-derived.

III.2 Estimand as a first-class node: body is the definition, id is the identity, the CLI compares ids not semantics

This section links back to ADR 0005, the cleanest demonstration in all of Cairn of "how mechanism holds an epistemic iron law without understanding content."

What it must hold: in Part I's case, the naive default pipeline produces claim A — "the housekeeping gene H is the top up-regulated gene"; a more rigorous path produces claim B — "H's 'up-regulation' is a sequencing-depth/dropout artifact, not biology." These two claims are opposing conclusions on the same estimand: they answer the same question (the true differential expression of H on that cell type, group A vs. group B), so they genuinely contradict and must be treated as a contradiction. Contrast another situation: one claim discusses "H's apparent fold change under log1p normalization," another discusses "H's fold change after downsampling to equal depth" — these two do not contradict; they answer two different questions, and forcing them into "one robustness conclusion" is exactly the laundering Part I excoriates: averaging answers to different questions into a fake "robust."

To mechanically distinguish the two situations, the tool must know whether two claims are answering the same question. But judging "is it the same question" is interpretation, and per ADR 0004 cannot go in the tool. ADR 0005's solution is to cut this interpretation in half:

  • The hard half to the agent: should these two claims be treated as the same estimand? Reuse an existing estimand id or mint a new one? This is the agent's judgment using its understanding of domain and statistics, written as the estimand node's body (a natural-language definition).
  • The mechanizable half to the CLI: the estimand node's id is its identity. A claim references it via estimand: <id>. When the CLI needs to decide whether two claims are "siblings of the same question," it compares only ids (string equality), never reading the body's semantics.

The "handle vs. content" split appears again: the body is the definition (for the reasoner to read), the id is the identity (for the machine to compare). The CLI compares ids not semantics — that is the whole secret of its being deterministic, who-agnostic, non-interpreting. It need not understand what an estimand is; it need only do string equality.

Why is estimand a handle the agent is willing to fill, while a "equivalence type" like E/N/U should not become a field (details in Part IV)? Estimand is the agent's declaration of its own intent — "what quantity am I measuring right now, which question am I asking" — which it already knows while analyzing: cheap, stable. Whereas E/N/U (judging the relationship between two specs as "equivalent/non-equivalent/uncertain") is an adjudication of the relationship between someone else's choices, requiring sibling-by-sibling comparison and contested fine judgments — exactly the think-field a fleet of agents will skip. And once made a field, it instantly becomes a new laundering surface: declaring "Type E equivalent" can legally collapse things. So estimand becomes a field, E/N/U does not; the latter stays the agent's reasoning lens, written into the body.

This estimand mechanism has its ceiling, which ADR 0005 itself names and Cairn never hides: comparing ids not semantics means it cannot catch fragmentation (two ids are really one estimand), nor conflation (one id stretched over two genuinely different estimands — a deliberate laundering act). The only thing that can block this is independent review of the estimand node itself, not the tool.

III.3 Trust axes that never merge + five deterministic gates

One of Part I's core arguments is canonical ≠ verified: a conclusion being "the currently agreed record" and being "independently confirmed true" are two things that never merge. Cairn splits "trust" into several never-collapsing axes, each either computed by the CLI or mechanically guarded by a CLI gate. Making them independent axes rather than one composite score is itself anti-laundering: a composite score would average things of different natures — "path-robust," "someone reviewed it," "wet-lab confirmed" — into one good-looking number, exactly the "pseudo-rigor appearance" ADR 0004 forbids the tool from producing.

The five gates below are each pure mechanism — enumeration checks or edge counts — and none requires the tool to understand content.

Gate 1: the reach-ground iron law — links back to ADR 0001. Every claim must stand on the ground. Formally, every claim has at least one edge, and walking up dependency edges (claim → claim) must eventually terminate at ground (a run, a file, a dataset, an external reference). No claim may stand on other claims alone — that is circular reasoning wearing provenance's clothes, exactly what Cairn guards against. This gate is enforced not at write time but at the draft → canonical promotion boundary (ADR 0001's "soft authorization, hard boundary"): a claim can first be cheaply recorded in draft state (edges optional), living in the owner's workspace, never seen by collaborators, new sessions, or snapshots; only when it is to be promoted to canonical does the CLI run that recursive reach-ground query and refuse promotion if it cannot reach the ground. Authoring is therefore low-friction and does not interrupt the agent's flow (low friction is itself the primary anti-forgetting mechanism), while any canonical a reader sees is always well-founded.

Gate 2: collapse-refusal — links back to ADR 0005. Different estimands may not collapse into one "robustness" conclusion. When an agent (or some orient logic) wants to treat a group of sibling claims as "different specs in the same multiverse," the CLI checks their declared estimand ids: as long as the ids are not all identical, it refuses the collapse. This is the enforcement end of III.2's iron law, mechanically preventing "averaging answers to different questions into a fake robust." It compares only ids, never judging whether the ids really stand for the same question — that is the ceiling, left to review.

Gate 3: resolution (no settled while a contradiction is open) — links back to an extension of ADR 0001. Here the case's contradictory pair is used as a concrete demonstration.

Resolution is a new axis orthogonal to lifecycle (draft/canonical), taking values open / settled. Its only reason to exist is Part I's real failure-as-cautionary-tale: a conclusion that should have stayed in doubt hardened into a "CLOSED NEGATIVE," because its contradictory sibling was forgotten. Cairn makes such hardening structurally impossible.

Concretely, in the case:

  • The agent writes claim A: "the housekeeping gene H is the top up-regulated gene." The CLI stamps: lifecycle: canonical is possible (it reaches the ground, pointing at a result table plus fingerprint), estimand: deg-H-groupA-vs-B.
  • Later a more rigorous path produces claim B: "H's up-regulation is a depth/dropout artifact, not biology." The agent writes contradicts: [claim-A] in claim B's frontmatter, and claim B's estimand is the same as claim A's (same question, opposing answers).
  • The resolution gate fires: the CLI sees an unresolved contradicts edge hanging on claim A (claim B opposes it, and neither side has been marked as settling the dispute), and so refuses to set claim A (or claim B) to settled.

The key is the temperature of this gate: it does not force claim A out of canonical. Claim A can remain canonical — it really is the current record produced by some reasonable, ground-reaching path — but as long as that contradiction edge is open, it can never reach settled. "Contested but canonical" is a legal, honest state. And the orient surface (see III.5) is required to surface this unresolved contradiction prominently, not bury it under a pile of canonical positive conclusions. Contrast Part I's failure: in pure re-derivation mode, a new session re-walks the default pipeline, again concludes "H is the top up-regulated," writes it into the conclusion, while claim B's refutation has long evaporated — and so the mistake comes back to life. Cairn's mechanism blocks this path: the contradiction is persisted as structure, inherited, and forever holds settled down. This fulfills ADR 0004's falsifiable assertion — "on a real contradiction case, persistence plus forced declared judgment must block the resurrection that re-derivation allows; if it can't, this substrate has not earned its right to exist."

Gate 4: verification's territory lock (the agent can never set verified) — links back to ADR 0006, Gate A. The verification axis takes values unverified / verified / contradicted / unverifiable, and territory-lockedly means exactly one thing: confirmed by something independent of your analysis system (wet lab, independent cohort). It almost always sits at unverified; its value is not in changing often but in being a structured, inheritable, unremovable warning light, so canonical can never quietly impersonate verified. This gate is a pure enumeration check: when a claim's provenance is an agent source, the CLI refuses to set verification to verified; only a non-agent provenance (experimental / human_reviewed) can reach verified. However confident the agent, however many convergent paths it ran, however beautiful its triangulation, it is structurally unable to light that lamp. Back to the case: that invariant robust across the whole garden (a set of activation/interferon signatures up, a cytotoxic marker down), even after passing the gold-standard donor-level pseudobulk, per-donor consistency, and cross-cell-type lineage logic — three layers of triangulation that lift "possibly true" to "more credible" — can still only sit at canonical (and at a higher corner inside canonical), never reaching verified, a line only a new experimental design, stepping outside the analysis system, can cross. Robust ≠ causal ≠ verified — this gate welds it shut.

Gate 5: corroboration (no promotion without a second asserter) — links back to ADR 0006, Gate B. Corroboration is a derived axis separate from verification, taking values self-asserted (one asserter) / cross-reviewed (≥2 distinct asserter ids). Like freshness, it is derived, not hand-set: the CLI counts how many distinct asserter ids are in reviewed_by, and refuses cross-reviewed if fewer than 2. It must be a separate axis, not a slot on verification, because: if "cross-reviewed" were made the middle slot of unverified < cross-reviewed < verified, then cross-reviewed would be read as "half-verified," exactly the impersonation Cairn forbids. So it lifts "two named agents both looked at the record" to two-named-asserter canonical — still canonical, never verified. Its ceiling, ADR 0006 says plainly too: a different id is not independence (the same model with a new shell has a new id and the same blind spot); the CLI only does "no second asserter ⇒ no promotion," while whether the second asserter is truly decorrelated (different family, why independent) is narrative written on the review edge, which the CLI carries but does not verify.

The five gates share one shape: each is an enumeration check or an edge count, none requiring the tool to understand content. This is the full picture of ADR 0004's "mechanism to the CLI" at the enforcement layer — the tool guards consistency between declarations, never the truth of the declarations themselves. The latter is the permanent ceiling, which Cairn loudly admits (details in Part IV).

III.4 Distrust the writer: asserter / reviewed_by / derived corroboration

This set of mechanisms links back to the spirit of ADR 0006, and also to an axiom from Part II: the agent does not trust its own assertions. If trust fields could be filled by the writer themselves, the whole anti-laundering is self-deception — an agent could stamp itself "verified, cross-reviewed." Cairn's answer is to take identity and trust out of the writer's hands and give them to the CLI to stamp as fact.

  • asserter: the agent (model / session / time) that made or last modified this claim, stamped deterministically by the CLI on every write, unfillable and unmodifiable by the agent. A modification by a different asserter creates a version (written into log.md), never a silent overwrite, so the original assertion and its correction both persist — corresponding to Part I's iron law: neither side of a contradiction may be dropped. asserter and fingerprint are two different things — the fingerprint signs the evidence artifact, the asserter records the agent making the assertion; one signs bytes, one records the author, never to be confused.
  • reviewed_by: a structured set of the asserter ids that reviewed this claim, likewise stamped as fact by the CLI. A review edge can carry narrative (explaining why this reviewer is independent, e.g., a different family), but the CLI only carries that narrative, it does not verify it. Verifying "is it truly independent" is interpretation, and per ADR 0004 does not go in the tool.
  • corroboration is derived from the above two, not hand-set — the CLI counts the distinct asserter ids in reviewed_by and computes self-asserted or cross-reviewed itself (i.e., Gate 5).

String the three together: identity (asserter) stamped by the CLI, review (reviewed_by) stamped by the CLI, trust (corroboration) computed by the CLI from the first two — the writer has nowhere on this chain to self-authorize. This is what "distrust the writer" looks like as it goes from principle to mechanism. It echoes that broader lock: any value an agent fills for a computed field (freshness / lifecycle / verification / corroboration / reach-ground) is overwritten by the CLI — the agent supplies intent handles (what it knows, cheap), the CLI monopolizes trust handles (computed, stamped on), and the two never cross.

III.5 Freshness derived from fingerprints, unknown is a legal state, fingerprint quality is tiered; plus CLI verbs, Skill axioms, OKF bundle layout

Freshness — links back to ADR 0002. Freshness answers "the artifact this claim once stood on — has it changed since I drew the conclusion?" It takes values fresh / stale / unknown. The most important mechanism decision: freshness is derived from the fingerprint of the evidence artifact, not from the computation process, and certainly not hand-filled by the agent.

Why not hash the process? Because the real environment guarantees discipline will lapse. Computation mostly runs directly via the agent, sometimes through a pipeline tool, sometimes not, sometimes in Python, and often on a remote HPC. Hashing the process (consuming the pipeline's DAG, or wrapping execution in cairn run --) covers only the few jobs that went through a pipeline, and hard-fails the moment that special step is forgotten: no node means no freshness at all. So Cairn instead stamps an artifact fingerprint on the evidence edge at authoring time (a content hash, degrading to a weak size+mtime fingerprint when unreachable), and freshness is just comparing the stored fingerprint against the current one — reachable and matching is fresh, reachable but changed is stale (and cascading along dependency edges: any stale dependency makes you stale too), unreachable or merely self-asserted-without-recheck is unknown.

unknown is a legal, honest state, not a failure. When a remote artifact is unreachable, unknown is the correct answer; the real enemy is a false fresh. This echoes Part I's anti-laundering: better to honestly say "I don't know" than to give false confidence. Fingerprint quality is tiered and shown on the badge: the content hash of a pipeline tool is top-tier (rigorous, and computed for free as a side effect of its own memoization), a self-asserted remote md5sum is an honest lower tier. The badge marks which tier it is, faithfully, never flattening fingerprints of different quality into one fresh/stale.

Bytes by reference + fingerprint, never ingested. Cairn never versions bytes itself, never ingests artifacts (ADR 0003: text into git as truth, artifacts referenced by path + fingerprint, never ingested); the git footprint is always text-only, and a multi-GB project still produces only a few hundred KB of claim text. When a content-addressed tool (e.g., DVC) is present and an artifact has a stable content-hash pointer, the CLI reads that hash as a top-tier fingerprint source. This is one example of the top of the "fingerprint quality tiering," not a second load-bearing leg alongside OKF. Its meaning is limited and honest: as long as that content hash is in git (e.g., a .dvc pointer versioned along with the claim), it can always be read as a top-tier historical fingerprint, pinning the claim to a recoverable byte description. But freshness still degrades gracefully per ADR 0002: when the bytes are currently reachable, compare the stored hash against the current one and give a reliable fresh/stale; when the bytes are currently unreachable (out of reach on a remote / external volume), the CLI still honestly falls back to unknown. The historical hash in the pointer lets the claim stay pinned and recoverable, but it does not let the CLI pretend fresh from a historical md5 when the bytes are unreachable.

CLI verbs. The CLI is the only write path — deterministic, auditable, doing the structural checks a schema cannot express. The verbs are roughly: head emits OKF's index.md orient surface (canonical claims + live freshness + unresolved contradictions/staleness surfaced prominently); add-claim (with --estimand, --evidence kind:ref (including dvc:), --depends-on-fork, --contradicts, --inherits-caveat, --provenance, --deflation-route, with the CLI stamping the asserter and computing the locked fields); add-estimand / add-confound mint those two node types; review <claim> --by <asserter> records a review edge (the asserter must differ from the claim's asserter for corroboration to move); plus refresh, validate (reach-ground and other gates), publish, drafts, status, reconcile (warn-only: it only flags "conclusions in the shared prose carrying no claim id," without pretending to have blocked anything).

Skill axioms. Cairn's way of making "judgment to the agent" real is to bake the operating axioms into a Skill (a markdown capability injection for Claude Code). The Skill is the only thing that can "cause" a claim to be written (the schema does not authorize it); the CLI + Store only constrain (refusing malformed writes, which the skill cannot enforce). The two are not competitors but different verbs: Skill = cause, CLI + Store = constrain. The axioms themselves — express don't resolve, declare the estimand, read the multiverse as possibilistic not probabilistic, contested forks default to unresolved, point at a deflation route, don't trust your own assertions — live in the Skill, not frozen into the tool, so adopting a better epistemic framework means changing the Skill axioms, not changing the schema. This is the bitter lesson cashed out at the architecture level: intelligence stays in the layer that reasons, the tool does only what can be deterministically verified without understanding. But the binding force must be stated honestly right here: Skill = cause but does not enforce; these axioms are a wish an agent can ignore, and v1 has no hook enforcing them behind the scenes. A Claude Code lifecycle hook that can hard nudge/block without relying on the agent's goodwill is v2's hardening; v1 relies only on CLI + Store to constrain malformed writes, and cannot stop an agent that simply does not call the skill and does not write a claim. The reader getting here should not overestimate the binding force of these axioms: they are design intent, not invariants v1 already enforces.

OKF bundle layout. A published Cairn store is a self-contained, portable OKF bundle, roughly the directories claims/, estimands/, confounds/ (the three node-file types) plus three top-level files:

  • index.md = the orient surface: the map a new session lands on to orient immediately — canonical claims, live freshness, unresolved contradictions and staleness surfaced prominently. Its discipline (ADR 0004) is surface, not bury: the negative, the contradictory, the stale may never be pressed down under a pile of canonical positive conclusions, because "washing away the negative" is exactly the mechanism of Part I's failure.
  • log.md = the timeline: snapshot history and corrections are written in OKF-native log.md; the time spine is the format's own, not a Cairn invention. Corrections leave a trace here as versions, never a silent overwrite.
  • snapshots/ = immutable freezes: each publish freezes a content-addressed, immutable snapshot (canonical only), letting a reader diff against the version they last saw. It is a portable frozen artifact, served identically by static files or by a future Cloudflare Worker — writes always stay local, reads can travel.

These three together give the physical form of Part II's "durable capture + parasitize OKF + bytes by reference + express don't resolve": judgments written as OKF and persisted instead of evaporating, bytes referenced by path + fingerprint and left in place (recoverable, not ingested), and Cairn itself, on top of this layer alone, mechanically and without interpretation, adding the "resistance" that keeps a conclusion carrying its scars all the way up.

Part IV — Boundaries and Falsification

This part answers a question no canonical document can dodge: what does Cairn solve, what can it never solve, and on what grounds should one believe it is not just old parts repackaged as a new system. It deliberately pushes in the opposite direction, putting every ceiling, every possible rebuttal, and every piece of prior art on the table, and stating honestly what Cairn simply does not touch.

A document that endorses itself does not deserve a future reader's trust. So this part first lays out the front-stage source of the adopted epistemology — which is itself a warning against tools of this kind — then uses it as a ruler to measure Cairn, finds that Cairn stands precisely in the zone those authors call "where tools most easily fail," and then explains why we still think this shape holds.

IV.1 The front-stage epistemology: what is a multiverse good for, anyway?

Part I already gave the plain-language definitions of these two terms; here we go straight to their scholarly positioning. The epistemic front stage this book adopts is Rohrer, Hullman & Gelman (2026), What's a multiverse good for anyway?, plus the companion piece on the statmodeling blog. Its argument needs full restating, because it is not an endorsement of Cairn but a warning against "multiverse-management tools," and Cairn is exactly a multiverse-management tool. The gist:

  1. The multiverse's real value is in reflection, critique, and "expressing uncertainty," not in returning a verdict. Spreading out the whole garden is most useful for forcing the researcher to see how many degrees of freedom they have, which settings are actually arbitrary, which choices the conclusion is sensitive to. It is a mirror, not a judging machine.

  2. When treated as a serious inferential tool, it fails. The precise failure mechanism: only when the analyses folded into the multiverse point at the same coherent estimand (which quantity you actually want to estimate, in which population, conditioned on what) does the spread of results have a clean interpretation. The moment the folded-in analyses are in fact answering different questions, that result distribution stacks two different uncertainties on top of each other: uncertainty about the answer (same question, method noise) and uncertainty about the question itself (these paths aren't the same question at all). Once stacked on one histogram, the two can never be separated again. The reader sees a wide distribution but cannot know whether it is wide because the question is hard or because oranges were piled in with apples.

  3. The multiverse is possibilistic, not probabilistic. This is the most easily misread, most deadly point. For the general reader: possibilistic means "these are all the reasonable analyses one could have done" — it enumerates possibilities; probabilistic means "each result carries a probability of being true." The multiverse gives you the former. So the distribution of effects must never be read as probability: an effect appearing in 900 of 1000 paths does not mean it has a 90% probability of being true. Those 1000 paths are not a random sample from some population; their "vote count" reflects how many look-alike paths you (or some convention) happened to enumerate, not the truth of the world. Higher frequency does not mean more likely true. Taking the mode as the answer and the proportion as a posterior probability is this tool's most common and most dangerous abuse.

  4. "A guise of rigor and completeness." This is the warning that recurs in the paper above, written directly into ADR 0004. A tool that mechanically interprets the multiverse — counting how many paths agree, averaging the effect, declaring "robust ⇒ probably true" — manufactures an appearance of rigor and exhaustiveness, and that appearance is itself the con: it makes a genuinely unresolved question look as if a neutral machine had solved it. Running a billion regressions and drawing a pretty distribution does not do the hardest judgment — "are these paths the same question" — it merely hides the undone judgment under the chart.

  5. The blog's one line is Cairn's direct reason to exist. The companion blog notes: when generating a multiverse was still expensive, "arbitrariness" was naturally capped by cost — no one had time to run a billion paths. But AI makes "generating a multiverse" nearly zero-cost; once it is, without matching discipline what you get is not more rigor but "questionable heuristics at scale" — multiplying already-unsound off-the-cuff judgments by a million.

This point 5 is exactly Cairn's positioning, and its dividing line from all prior art. AI has industrialized the generation of judgment; what Cairn wants is to match it with an equally industrialized visibility of judgment: not to return a verdict (precisely the failure mode the paper warns of), but to keep every industrially-generated judgment carrying, as it aggregates upward, how it arose, which fork it is conditioned on, what refuted it, whether anything looked at it independently. Cairn does not try to supply this tool with the inferential statistics it lacks; it accepts that this tool is possibilistic, and does the one thing a deterministic tool can honestly do: prevent that possibilistic picture from being quietly read as a probabilistic verdict. Hence Cairn itself never counts paths, never averages, never returns a robustness score — that would turn it into the paper's machine for manufacturing "the guise of rigor," exactly the convergence engine that Part II's first wall deleted.

It must be said honestly that Rohrer, Hullman, and Gelman do not endorse Cairn. What they prescribe is an attitude prescription for human researchers — use the multiverse as a mirror, not a judging machine; express uncertainty, don't resolve it. Cairn is a tool, and stands precisely on the ground they call "where tools most easily fail" (it manages a multiverse, it aggregates across judgments). We cite them because we agree with their diagnosis, and hard-coded the warning "the tool must not return a verdict" into the design (ADR 0004) — not because they approve of the tool. This distinction runs through all of Part IV: every time we approach a predecessor, we approach their diagnosis, not their permission.

IV.2 The permanent ceiling: consistency is not truth

Cairn's CLI (the command-line tool, the sole write channel) can enforce exactly one thing: that what you write is consistent with itself and with the labels you declared. It can never enforce the second thing: that what you declared is true. This is not a temporary v1 defect but the permanent ceiling of substrates of this kind, written at the end of ADR 0004 and restated in their own slice by ADR 0005 and 0006.

Concretely, all the CLI can do are mechanical acts: compute a signature on an evidence artifact by fingerprint (a signature computed over the artifact's content), validate that a claim's dependency graph reaches the ground (reach-ground), set gates on declared labels (e.g., refusing to merge two claims as one multiverse when their declared estimand ids differ), and store things as OKF. These acts share one trait: they can be done without understanding content. That is exactly why they are deterministic and consistent across people/agents, and exactly their boundary — a machine that does not understand content cannot judge whether content is true.

So the precise shape of the ceiling is: the agent can launder by mis-declaration. Cairn's first principle is anti-laundering. But the CLI resists structural laundering (dropped edges, circular reasoning, treating stale as fresh, passing the agent's own work off as independent verification); it cannot resist semantic laundering:

  • ADR 0005's slice: the CLI compares the estimand's id (string equality), never reading the meaning of the estimand definition. So an agent can label two claims that are really asking different questions with the same estimand id (conflation, two estimands stuffed into one id), fool the merge gate, and average oranges and apples into one chart — exactly the failure IV.1's paper describes. Splitting one estimand into two ids (fragmentation) fools it equally. The CLI cannot see it, because seeing it requires understanding the definition, and understanding is judgment, and judgment is not in the tool.
  • ADR 0006's slice: the CLI counts the number of distinct asserter (the agent that made or last modified a claim) ids. It mechanically upgrades "≥2 distinct ids" to cross-reviewed. But a different id is not real independence — the same model with a new shell gets a new id, carrying the identical blind spot. The CLI cannot catch this fake review; why a reviewer is truly independent (a different model family, why uncorrelated) is only narrative written on the review edge, which the CLI ferries but does not verify.

This ceiling is the core of Cairn's honesty: canonical (adopted as the currently agreed record) never equals verified (independently confirmed by something outside the analysis system, e.g., wet lab, independent cohort). The CLI guards "what you wrote is consistent with what you declared," and structurally guarantees that canonical cannot quietly impersonate verified (ADR 0006 locks both sides: the agent can never set verified; cross-review is deliberately kept off the verification axis, lest cross-reviewed be read as "half-verified"). But it cannot guard "what you declared is true." Robust ≠ causal ≠ verified — this is the book's invariant, and the plainest statement of this ceiling.

The only mitigation is not a stronger tool but the axiom of writer-distrust itself: by default every provenance is challengeable, to be looked at independently by a different asserter. This mitigates mis-declaration but never closes it — because independence is itself a judgment, which lands back under the ceiling. Cairn does not pretend to have closed this hole; it only guarantees the hole stays visible (the warning light is structure, not narrative, and summarization cannot wash it off).

IV.3 The falsification test: maybe you don't need to build a system at all

A canonical document must carry a bullet aimed at itself. For Cairn, the sharpest one is this rebuttal:

Maybe you don't need to build any system at all. Maybe all you need is (a) a set of off-the-shelf parts, plus (b) a discipline you follow when writing the prose.

OKF can store claims; DVC can manage bytes and versions; nanopublication and SEPIO (see IV.4) structured "claim + evidence + provenance" decades ago; the multiverse literature long ago told you how to spread the garden and read it possibilistically. Bolt these together, then require everyone writing the prose to conscientiously note beside each conclusion "this is conditioned on which fork, refuted by what, whether stale" — haven't you obtained all the anti-laundering Cairn promises, without building anything new?

This bullet must be taken seriously, not waved away. It has an operational falsification test, and Cairn's own ADR 0004 already wrote that test at its end as the criterion "this store must earn its keep": take the contradictory pair of claims, assemble them on the running case, and see whether off-the-shelf parts + writing discipline alone can really block the resurrection of the contradiction.

That contradictory pair (details in Appendix NK; only the skeleton here): the naive default pipeline produces claim A — "a housekeeping gene H is the top up-regulated gene"; a more rigorous path produces claim B — "H's up-regulation is a sequencing-depth/dropout artifact, not biology." Same estimand, opposing conclusions. The falsification test asks:

  • A new agent session (fresh session), armed only with off-the-shelf parts + a "please be conscientious when writing the prose" discipline, reads this analysis from scratch half a year later — will it, because claim B at the time lived only in some conversation and was not persisted as structure, re-walk claim A, write that refuted "H is top up-regulated" into the summary again, and wash away claim B's refutation?

If it will, then "off-the-shelf parts + writing discipline" did not block the resurrection of the contradiction, and the mechanism Cairn claims blocks it is the core of ADR 0004: judgment persisted as structure, inherited by the next session rather than re-derived. Re-derivation (each new session re-deriving from raw context) is precisely the mechanism by which a refuted "closed/negative" conclusion comes back to life; persistence + the frontmatter handle (state the next agent can read without rereading the prose) is what welds this resurrection path shut. Writing discipline is a wish (the owner "sometimes forgets," a v1 ceiling explicitly admitted in CONTEXT.md), whereas storing the contradiction as undroppable structure and forcing the orient surface to surface unresolved contradictions rather than bury them under canonical positive conclusions is a mechanism.

So the honest conclusion of this falsification test has two layers:

  1. If, on a real case, "off-the-shelf parts + a self-disciplined person/agent" can also reliably block the resurrection of that contradiction, then Cairn has not earned its keep, and it should be cut down to "a set of conventions + a skill discipline," with no CLI and no store. ADR 0004 explicitly accepts this verdict.
  2. We bet it cannot block it, not because the tool is smarter, but because discipline does not scale and mechanism does. AI has industrialized the generation of judgment to the order of "a billion paths in an afternoon"; to pair that with "a human conscientiously noting the scars beside each conclusion" is to meet something already industrialized with something that does not scale. Cairn bets on exactly this mismatch: when generation is industrialized, visibility must be industrialized too, and industrializing visibility requires deterministic mechanism (distrust the writer, undroppable contradiction structure, mechanical consistency gates), not stronger self-discipline. This bet is falsifiable, and this section gives the concrete way to falsify it.

IV.4 The map of prior art: you are not unique

For anti-laundering, the vast majority of parts are not Cairn's invention. This section honestly draws that map and pinpoints which intersection Cairn stands on — without conscripting any piece of prior art into "an endorsement of Cairn."

  • Nanopublication (since 2010) + SEPIO. For the general reader: a nanopublication is a format that packages a minimal scientific assertion, together with its evidence and provenance, into a machine-readable structured unit; SEPIO (Scientific Evidence and Provenance Information Ontology) is an ontology describing "evidence–assertion–asserter" relationships. These two are biology-native "claim + evidence + provenance" tools, a decade-plus older than Cairn. Cairn's asserter concept is borrowed directly from SEPIO's asserting agent; the claim/evidence/grounding-edge three-node structure was done by nanopub long ago. This whole layer Cairn did not invent.
  • OKF. The claim storage format, the frontmatter-handle / body-narrative division of labor, the concept-file directory layout, the external viewer — all parasitize on OKF. ADR 0003 was explicitly refactored into "Cairn no longer maintains a format and frontend it invented." Format and presentation, Cairn does not own.
  • Byte-versioning / content-addressed tools (e.g., DVC). For the general reader: such tools version and recover the bytes of large files (leaving only a small pointer in git). Cairn never versions artifacts itself — it references them by path + fingerprint (ADR 0003), and when such a tool is present and an artifact has a stable content-hash pointer, the CLI conveniently reads it as a top-tier fingerprint source. Byte-versioning and recovery, Cairn does not own and does not parasitize as a load-bearing leg; it only piggybacks on the content hash when present.
  • targets / Snakemake. For the general reader: these are data-analysis pipeline tools that record "which artifact was produced by which step, whether it needs rerunning." When present, they conveniently provide a high-quality content fingerprint (the top-tier source of freshness). Orchestration and this "free source" of artifact fingerprints, Cairn does not own; it only piggybacks when present.
  • Multiverse / garden-of-forking-paths literature (Gelman & Loken, Steegen et al., Rohrer/Hullman/Gelman 2026). The whole epistemology of "spread the garden, read it possibilistically, don't resolve, express uncertainty" is someone else's. Cairn adopts it, does not invent it.

So what is Cairn's own? Not any single part, but a four-dimensional intersection:

(in-flight writing) × (agent writes) × (anti-laundering as first principle) × (distrust the writer).

Dimension by dimension, contrasted with the predecessors:

  • In-flight (written on the spot, in the workflow). Nanopub / SEPIO are mainly a post-publication structuring, an archival layer for machine retrieval; Cairn's claim is written by the agent during normal analysis, in a sentence, low-friction, draft-soft (low friction being the primary anti-forgetting mechanism). What it captures is judgment as it happens, not a post-publication tidy-up.
  • Agent writes. Prior tools' primary writer is a human researcher or curator; Cairn is agentic-AI-ready-first, its primary interface is the agent loop, its axioms baked into a skill, its primary writer an AI agent. The object being aligned to therefore changed — the whole design (the handle so the next agent need not reread the prose, contradictions that must surface to the orient face) serves "the next AI session."
  • Anti-laundering as first principle. Nanopub's first principle is machine discoverability and reuse; OKF's is knowledge representation; DVC's is reproducibility. None of them has as its first principle "let a conclusion carry its scars as it aggregates upward, across agents, across time." Cairn takes anti-laundering as the sole design driver and cuts everything against it — it adds only the "resistance" layer (bytes referenced by path + fingerprint and never ingested, format via OKF, Cairn adds only resistance).
  • Distrust the writer. This is the sharpest and most counterintuitive dimension. Prior tools mostly implicitly trust the writer to fill fields honestly; Cairn writes distrust-of-the-writer into its axioms: provenance is challengeable by default, the agent can never set verified, trust can only rise through the independent review of a different asserter, and even "a different asserter" is honestly admitted not to equal "truly independent." In a world where the writer is itself an AI that makes the same mistake at scale, distrusting the writer is the only honest default.

The honest conclusion of this map: Cairn owns no single part; it owns this intersection, and the obstinacy of carrying this intersection through as a first principle. No single piece of prior art, taken alone, endorses Cairn; they are the shoulders Cairn stands on; the stance of standing — this four-dimensional intersection — is Cairn's own.

IV.5 What it doesn't solve: drawing Cairn's no-go lines explicitly

An honest boundary is half "stating clearly what you solved" and half "stating clearly what you deliberately do not touch." What Cairn does not touch, and does not pretend to touch:

  • Orchestration, compute, cost. Cairn does not run analyses, does not schedule, does not manage HPC, does not optimize "which paths to run, how many." Generating the multiverse is not Cairn's business (that is the business of agent + targets/Snakemake + remote compute); Cairn manages the visibility and consistency of judgments only after they have been generated. The front-stage blog says AI makes generation trivial — Cairn catches the mess after trivial, not the generation itself.
  • Hooks (not in v1, left to v2). v1's sole authorization driver is the skill, and the skill is "a wish an agent can ignore." A Claude Code lifecycle hook that can nudge/block without relying on the agent's goodwill is v2's hardening. This means a v1 claim really can be forgotten — publish does only a warn-only reconcile (reporting conclusions in the prose carrying no claim id, drafts that never landed), it does not block. This is an accepted ceiling, not a hidden bug. Writing it here is so that no one mistakes v1 for having enforced anything — what v1 enforces is "making the lapse visible," not "pretending the lapse was prevented."
  • The judgment of independence. This recurs, but deserves its own line: the CLI counts the number of asserter ids, never judging real decorrelation. "Are these two asserters truly independent" is judgment, not in the tool. Cairn does not solve independence; it only lets "claimed independence" be ferried as narrative on the review edge, to be scrutinized by the next reader.

These three together show Cairn is a narrow tool. Its honesty comes precisely from its narrowness — it does only what can be deterministically verified, and pushes everything requiring understanding (generation, judgment, independence) onto the agent or leaves it to the future. A tool claiming to have solved all of these would become exactly the front-stage paper's machine for manufacturing "the guise of rigor."

IV.6 A sub-narrative seriously considered, then abandoned: E/N/U

A passage is reserved for an idea that was once at the design's core and was ultimately abandoned, because the process of its abandonment is itself a concentrated test of all the foregoing principles: E/N/U — the equivalence / nonequivalence / uncertainty trichotomy proposed by Del Giudice & Gangestad (2021).

For the general reader: facing each analysis-decision node in the multiverse (normalization method A or B?), E/N/U wants to slap a type label on each node — are these two choices equivalent (pick either, the result should be the same), nonequivalent (different choices give different, meaningfully different things), or uncertain (can't say which). In early Cairn designs, E/N/U was at one point treated as the first-class structured field, the handle telling the merge/orient logic "when may these sibling specs be merged," and it was carried through several rounds of design.

Then it was abandoned. The reason is that several principles erected earlier in this book each fired a shot at it, each shot fatal:

  1. The bitter lesson. For the general reader: the bitter lesson is a repeatedly confirmed experience in AI research — welding a specific human-designed framework into a system almost always loses, long-term, to "letting the system learn/reason with general capability itself." Welding a particular 2021 three-bucket classification into the schema is freezing a human framework into the tool. A capable agent will use E/N/U and surpass it (a better carve may exist tomorrow); a tool bound to one taxonomy ages fast. This is exactly the bitter-lesson anti-pattern ADR 0004 keeps naming — hard-coding human heuristics where a reasoning system ought to reason.
  2. The framework's own authors throw cold water on it. The ones throwing cold water on E/N/U are precisely Rohrer, Hullman & Gelman (2026), our front stage. They note that the E/N/U distinction holds in theory but in practice "depends heavily on the researcher's domain knowledge and statistical chops," and that Type U (uncertain) will often be the majority. A three-bucket enum whose modal value is "uncertain" is not worth enforcing. And another layer: without preregistration (registering in advance how you intend to analyze), the researcher will tend to classify a node by whether it supports the conclusion they want — the E/N/U label itself gets polluted by the garden of forking paths. It is not the garden's antidote; it becomes another fork in the garden.
  3. Friction discipline. For a field to actually get filled, it must be cheap — the agent can fill it off the top of what it already knows. Here the contrast between estimand and E/N/U is decisive: estimand is the agent's cheap declaration of its own intent — "which quantity am I estimating, which question am I asking" — which the agent already knows while analyzing: cheap and stable. E/N/U is an adjudication of the relationship between someone else's choices — requiring pairwise comparison of sibling specs, contested fine judgments. This is exactly "the think-field a fleet of agents will collectively skip." A field that gets collectively skipped is worthless as enforced structure.
  4. Enforcing E/N/U is still a laundering surface. If E/N/U is a field, the agent can declare "Type E, equivalent" to legally merge sibling specs away, settling a question that should have stayed open. This is isomorphic to estimand's conflation hole, but worse: estimand at least declares the agent's own intent, while E/N/U declares an adjudication of someone else's choices, more easily wielded as an "objective ruling" to deflect with. Not making it a field removes this laundering vector outright.
  5. Estimand already ate E/N/U's most load-bearing half. This is the key to abandoning it without losing any mechanism. The truly load-bearing part of E/N/U is effect-nonequivalence — "different estimand ⇒ different question ⇒ incomparable." And that half is already fully eaten by the estimand handle: the CLI refusing to merge siblings declaring different estimand ids is mechanically enforcing effect-nonequivalence. The remaining nonequivalences (measurement; power/precision — "same estimand, but is spec A more efficient/powerful than B?") are case-by-case domain judgments that should be left to the agent as body narrative anyway. So abandoning the E/N/U field loses no mechanism, only a will-be-skipped, will-be-abused, will-age enum; the mechanism half was long ago taken over by estimand in a cheaper, more honest way.

These five shots together: E/N/U's fate is a joint performance of all the book's principles — judgment to the agent (0004), cheap handle over expensive think-field (0005), leave no laundering surface, don't weld an aging human framework into the tool, take over the most load-bearing half with deterministic mechanism, leave the rest as inheritable narrative. It was seriously considered over several rounds, then unanimously vetoed by these principles — which shows the principles are not after-the-fact rhetoric; they really do overturn a design the designer himself once favored.

The closing must return to the honesty running through Part IV: Del Giudice & Gangestad did not endorse "abandoning E/N/U," and Rohrer et al. did not endorse Cairn. Del Giudice & Gangestad are proposing E/N/U; we, after applying principles learned elsewhere to it, decided not to weld it. The cold water Rohrer, Hullman & Gelman threw on E/N/U is an attitude prescription for human researchers — "don't trust this trichotomy too much to tell things apart in practice"; we read that prescription as "then it should all the more not be made an enforced field," but that is our inference, not their conclusion. Likewise, their whole warning about the multiverse is written for humans to use a mirror more humbly; Cairn is a machine, and consciously stands on the ground they call "where the machine most easily turns the mirror into a judging machine." We share their diagnosis — the multiverse is possibilistic, robust is not true, mechanical interpretation manufactures the guise of rigor — but the permission we signed ourselves: we bet that, in a world where judgment is already industrially generated by AI, a deterministic machine that does only visibility and resolutely returns no verdict is the only shape worthy of that diagnosis. Whether this bet is right, the two falsification openings Part IV gave (mis-declaration laundering under the permanent ceiling, whether "off-the-shelf parts + discipline" suffices on the case) will answer; this book does not vouch for it.

Appendix NK — The full case study (anonymized)

This appendix grounds the case running through the book from the abstract into a concrete, fully anonymized data-analysis scene. It cites no real project, lab, chromosome, or gene identity; what is retained is only the epistemic skeleton, with all numbers rounded for illustration, conveying order of magnitude only. As you read this narrative, keep the book's overarching thesis in mind: what is worth carrying upstream is not the pretty number of some one path, but that little bit that is robust across the whole garden and still carries its scars. Part I already distilled three lessons from this case (the silent default is the most hidden fork, the payoff is the invariant, robust ≠ true); this appendix gives the full narrative, adds two honest corrections (to keep the story from being told as more respectable than the truth), and ends with a phenomenon → Cairn design mapping.

NK.1 Setup: a simple request to "compare two patient groups"

The data is a single-cell immune sequencing dataset (single-cell: a technique that dissociates tissue into individual cells and measures gene expression cell by cell). There are two patient groups, call them group A and group B. The task is defined by one very plain sentence: "Is there a difference in some immune cell type between these two patient groups? Run a differential expression analysis on that cell type."

Differential expression (DEG, differentially expressed genes): between the two groups, test gene by gene whether "this gene's mean expression differs systematically between groups," and list the genes that pass the significance threshold. This is the most routine, most default-pipelined step in single-cell analysis. Precisely because it is so routine, it hides a whole garden of forking paths behind a surface that "looks like just running a default function."

Before getting hands-on, record a deadly technical fact that is the root of all the chaos to come:

Group A's samples are sequenced more deeply (each cell gets more sequencing reads), and use a different library-prep method: group A pooled multiple patients into one library (pooled), group B built a library per patient (per-sample). The result is that "sequencing depth," "library-prep method," and "group" are fully collinear — they always vary together in the data, and none can be pried apart from the others.

This must be kept distinct from a "fork." A fork is the analyst's choice: which normalization, which test — degrees of freedom where "another route could have been taken." A confound is a flaw in the experimental design: depth, library prep, and group welded together, born into the data, outside the analyst's choice. This case trips on both at once, and they require two completely different treatments (exactly what the later mapping separates): a fork can be narrowed by more analysis, more validation; a design confound cannot be pried apart by any amount of analysis — you can only change the experimental design, or honestly mark it and let it infect downstream.

NK.2 Layer 2 multiverse: six each-reasonable settings, DEG count swinging from ~80 to ~1200

This book keeps only "Layer 2" of this case: after the cell-type labels were long settled and the analysis unit was no longer in dispute, the modeling multiverse purely about "how to normalize, how to handle depth, which statistical test." (Further upstream there is another layer, the annotation multiverse of "which cells count as this type," which the book omits.)

After settling which cells to compare (in order of magnitude, group A about 200 cells, group B about 600 cells), the depth confound immediately bites: group A's cells are generally sequenced more deeply, so many genes appear "up-regulated" in group A merely because they were "not detected" in the shallower group B cells (dropout, true expression measured as 0 at low depth). For "how to handle this depth difference," every approach is reasonable, and every one gives a different result (significant DEGs rounded for illustration, up / down):

  • Standard log-normalization + cell-level Wilcoxon test (software default) → about 1200 / 100, top-ranked: housekeeping gene H (artifact).
  • A different depth-aware log-normalization (no downsampling) → about 220 / 70, top-ranked: housekeeping gene H (artifact).
  • Downsample the deep group to equal depth + standard normalization → about 490 / 150, top-ranked: a real-signal gene.
  • Downsampling + depth-aware normalization → about 80 / 70, top-ranked: a real-signal gene.
  • Patient-level pseudobulk (aggregate per patient, then test) → about 530 / 70, top-ranked: oscillating between H and the real signal.
  • Pseudobulk (only the patient subset with enough cells) → about 290 / 170, top-ranked: a real-signal gene.

"How many differential genes" swings from ~80 to ~1200, and "which is the top gene" flips back and forth between a real signal and a technical artifact. The most naive path (the software default) happens to be the worst: its top up-regulated gene is a housekeeping gene H expressed in nearly every cell (a housekeeping gene maintains the cell's basic operation and should have no between-group difference). H appears "group-A-specifically up-regulated" purely because it was dropped out to 0 in the shallower group B cells. A complete technical artifact, crowned first place by the default pipeline.

This is where the case's sharpest contradiction is planted, to be formally posed in NK.4. For now, remember this section's lesson: if one only reports "we found about 1200 up-regulated genes, top is H," it sounds certain, objective — but it is just one path in this garden, and the worst one.

NK.3 The multiverse's payoff: the invariant that survives across all paths

Run the whole garden, and the most valuable output is not the number on any single path but the invariant: the bit of signal that stably appears under every setting. In this case, no matter how normalization, depth handling, or statistical test is swapped, the following set of directions is always present:

A set of activation / interferon-response signature genes is up-regulated in group A; a cytotoxic marker gene is down-regulated.

That real-signal gene ranks first or second across all six settings. What is robust across the whole garden is what is worth believing. This is the constructive meaning of multiverse thinking: not nihilistically declaring "everything is arbitrary," but teaching you to report the stable manifold rather than some cherry-picked path.

But a brake must be put on "robust" immediately, exactly the boundary this book stresses repeatedly: robust ≠ true. "Robust across all analysis paths" proves only that this conclusion does not depend on the analyst's degrees of freedom; it does not prove the conclusion is real biology. It corresponds to canonical (the status of being deemed "to stand" by the current methodological system), not verified (confirmed true by territory independent of the analysis system). Misreading "robust" as "true" is exactly the laundering this book defines: washing a conclusion that originally bore conditions and scars into a clean, good-looking "fact" you can take and use directly.

NK.4 The contradictory pair: same estimand, opposing conclusions

Now formally pose the contradiction planted in NK.2. The two claims below target the same estimand — "on this cell type, the expression difference of housekeeping gene H in group A relative to group B." The two claims ask the same quantity, yet give opposite answers:

  • Claim A (produced by the naive default path): "The housekeeping gene H is the top up-regulated gene of this cell type in group A." From the software default pipeline, its evidence line the DEG table under default settings.
  • Claim B (produced by the more rigorous path): "H's 'up-regulation' is a sequencing-depth / dropout artifact, not biology — after depth-matching, or patient-level aggregation, H's between-group difference vanishes." From the evidence lines of the downsampling path and the pseudobulk path.

This is not "two different questions each with its own answer." Were it that, they should not be compared at all. They are two opposing answers on the same estimand. This is exactly the shape the book wants the tool to hold: in a real scenario, it was precisely this kind of contradiction that got forgotten, with the "looks easier" one (the naive default of Claim A's kind) quietly hardening into the project's final conclusion, while the claim that refuted it evaporated. Cairn's first-principle reason to exist is to prevent this forgetting: both claims must be persisted, neither may be silently deleted, and as long as the pair remains unadjudicated, the conclusion on this estimand may not be marked "settled." The tool itself does not adjudicate who is right — it has no standing to make that judgment; it only mechanically guarantees "the contradiction is present and visible on the orient surface," leaving adjudication to the reasoning agent and ultimately the territory.

NK.5 Triangulation: lifting "possibly true" to "more credible," but never reaching verified

"Robust to analysis choices" alone is not enough. To tell whether NK.3's invariant is real biology or another, more hidden technical artifact, three mutually independent things were further done — this is triangulation: using several evidence lines that share no bias to converge on the same conclusion, each additional independent line making the conclusion a notch more credible.

  1. Patient-level pseudobulk (the recognized gold standard). Aggregate each patient's target cells into one "pseudo-bulk" sample first, then compare between groups. This both avoids treating one patient's many cells as mutually independent samples (pseudoreplication) and properly models depth with a principled method. That set of activation / interferon signal up, cytotoxic marker down, passed the gold standard — not merely a cell-level statistical artifact.
  2. Per-patient consistency. The real-signal gene is high in every patient of group A and low in every patient of group B, fully consistent in direction, not driven by one or two extreme patients.
  3. Cross-cell-type lineage logic. Put the same gene set into other cell types: the activation signal is pan-lymphoid, while the down-regulation of that cytotoxic marker appears only in lineages with cytotoxic function, absent in cell types without it. A blind technical artifact would not "recognize" the cytotoxic lineage, so this direction fits biological logic, not just a numerical coincidence.

All three lines point the same way. But added together they still do not reach verified. Triangulation climbs a ladder inside canonical: robust to analysis paths (weakest) < consistent across patients < fits independent biological structure (strongest). This ladder lets a canonical conclusion approach that line as closely as possible, but never cross it. Only the territory crosses that line — a wet-lab experiment, an independent cohort, an independent measurement apparatus, something independent of your entire analysis system answering back to confirm. Triangulation lifts a conclusion from "possibly true" to "more credible," which is valuable; but calling "more credible" "verified" is laundering once more.

NK.6 The ineradicable residue: only a new experimental design will do

Finally, admit honestly: there is a question no run through the whole garden can fix, because it is not a fork at all but NK.1's design confound.

That up-regulation of activation / interferon signal might be real biology (group A's immune microenvironment really is more activated), or it might be technical: group A was all pooled library prep, group B was per-sample, the two groups differ systematically in "library prep / processing method," and a processing difference itself induces stress and interferon signaling. The key:

Downsampling can align the one axis of "depth"; pseudobulk can align "pseudoreplication." But no analysis method can pry the "pooled vs. per-sample library prep" confound out of "group," because it is fully collinear with group.

Running through the whole multiverse proves that "the signal is robust to analysis choices"; it cannot prove this is group A's biology, because the confound remains untestable. This is the case's deepest lesson, and it lands the iron law the book keeps returning to:

Multiverse analysis damps researcher degrees of freedom; it cannot fix a confound in the experimental design. A result robust across all analysis paths may still be driven by the confound. Robust ≠ causal ≠ verified. To truly answer this question needs better data (per-sample library prep, target-cell-enriched, comparable samples), not smarter statistics.

This residue must be explicitly recorded, and automatically inherited by every downstream claim that references it; otherwise it gets quietly dropped layer by layer in summaries, and the conclusion is washed into a clean, scar-free fact. This is the book's core demand for "anti-black-boxing": let the confound exist as a first-class node with a single definition, infecting downstream as a graph edge, rather than being copied into a prose caveat that will sooner or later be lost.

NK.7 Two honest corrections

The story is already quite pretty: a robust invariant, triangulation, an honestly-marked residue. Precisely because it is pretty, two patches must be applied, lest the book itself demonstrate the very laundering it most despises: rewriting a stumbling, real process into a more methodologically self-aware, more respectable version.

Correction one: this process was passive, data-triggered post-hoc exploration, not proactive weighting.

The real sequence was this: the analysis started from the software default (no one planned to do a multiverse from the outset), ran out and read an absurd number (about 1200 up-regulated genes, top a housekeeping gene), and only then went back to remediate — tried downsampling, tried other normalizations, tried pseudobulk. The multiverse was forced into being by an absurd result, not a discipline present from the start.

This must be nailed down, because it is precisely the pattern the garden of forking paths worries about, not its antidote: the analysis path is data-contingent — "decide the next analysis step after seeing the data." Beautifying this process into "the analyst proactively weighting each path by argued grounds" is false. The honest version is: the analyst was pulled along by the data and only retrofitted discipline afterward, and this "post-hoc remediation" itself carries survivorship bias — only the steps that happened to give an absurd number ever got a chance to be doubted, to be multiverse'd.

Correction two: the real blind spot is the never-doubted "silent defaults."

In this whole story, the only steps multiverse'd were the ones that made the analyst suspicious: normalization (because the ~1200 number was too absurd), depth handling (because housekeeping gene H as top was too suspicious). The defaults that "looked right" from the outset — QC thresholds, highly-variable-gene selection, the number of principal components (PCs) — were never doubted from start to finish, never folded into any multiverse.

This is where the garden of forking paths truly buries its bodies. That worst software default was caught precisely because it gave an absurd number; defaults that give "looks reasonable" numbers will never trigger suspicion, so the bias they introduce sails unobstructed all the way into the final conclusion. The probability a step gets doubted depends on how absurd its output is, not on how dangerous it actually is — a systematic sampling bias uncorrelated with real risk. The book therefore sets the true target of "anti-laundering" on these silent, never-suspicion-triggering defaults: the most dangerous form of laundering is not leaving a refuted conclusion in place, but letting a never-doubted default quietly, respectably, decide the conclusion.

NK.8 Mapping: each phenomenon in the case → which Cairn design

Map each epistemic pressure point in the narrative above back to a specific mechanism argued earlier in the book. How to read: each entry first gives the phenomenon that actually happened in the case, then the Cairn design used to resist it, plus the book part / ADR that design links back to. Note: every right-hand mechanism obeys the same overarching discipline — the tool does only what can be deterministically verified, never interprets, never adjudicates, never scores; all judgment belongs to the agent.

The contradictory pair: Claim A (H is top up-regulated) vs. Claim B (H is a depth dropout artifact), same estimand, opposing conclusions. → The resolution gate + keystone acceptance test. Both claims are persisted, neither may be silently overwritten (ADR 0004, Part III.4); as long as the contradicts edge between them is unadjudicated, the conclusion on that estimand is refused the settled mark (the resolution axis, orthogonal to lifecycle, Part III.3 Gate 3). This is exactly the "earn its existence" keystone acceptance test (Part IV.3): reproduce this contradiction, assert that the gated store blocked the hardening of a contradicted conclusion and surfaced the contradiction on the orient surface; if it cannot block it, this substrate has not earned its existence. The tool does not judge who is right, only mechanically guarantees the contradiction is present and visible.

The six-setting swing (~80↔~1200) + the invariant that survives across all paths. → Possibilistic reading + never return a verdict. Cairn does not count how many paths agree, does not average effects, does not score robustness (ADR 0004, explicitly out of scope, Part II.1 / IV.1). The multiverse is expressed as a possibility set of "which conclusions could hold," not "path-vote probability" (probabilistic) — this is the agent axiom in the Skill, not a CLI mechanism. The tool only persists which fork each claim is conditioned on (depends_on_fork), letting both "the swinging" and "the invariant" be present each on its own; the verdict (which is the real signal) is left to the agent.

The three triangulation lines (gold-standard pseudobulk / per-patient consistency / lineage logic) lifting "possibly true" to "more credible." → evidence_lines (multiple named evidence lines) + an intra-canonical gradient, but never reaching verified. Each of the three lines is recorded as a named evidence_line, landing the conclusion's "feet" on multiple mutually-independent foundations. Together they raise the claim a notch inside canonical (steadier, more credible), but the CLI structurally locks the agent out of verified: the verification axis is territory-locked (ADR 0006 Gate A, Part III.3 Gate 4); when provenance is an agent source, the CLI refuses verified, and only non-agent territory evidence (experimental / human confirmation) can light that lamp. However strong the triangulation, it is only a climb inside canonical, never crossing that line.

The ineradicable design residue (pooled vs. per-sample collinear with group, treatment / interferon effect inseparable). → A confound node + deflation_route + robust ≠ verified. The design confound is recorded as a first-class confound node (single definition, with an unerasable flag), and every downstream claim inherits it via an inherits_caveat edge — the infection is a graph edge, not a string copy that will sooner or later be lost (Part III.1). At the same time a deflation_route is recorded, honestly stating "this uncertainty can only be shrunk by changing the experimental design, not by more analysis" (Part II.4), pointing the residue at an exit rather than hoarding it. This mechanism turns "robust ≠ causal ≠ verified" into structure.

The passive process (default start → read an absurd number → only then go back to remediate). → Conservative by default + distrust the writer. Cairn does not assume the analyst proactively weighted the paths; its posture is conservative by default — a contested fork defaults to unresolved, a conclusion defaults to unverified (a warning light that never goes out). The companion is writer-distrust: the CLI overwrites the agent's self-reported values for all computed / trust fields (freshness, lifecycle, verification, corroboration, reach-ground) (ADR 0004 ceiling, trust-field lock, Part III.4 / IV.2). This precisely offsets the overconfidence that "passive post-hoc exploration" brings.

The silent defaults (QC / highly-variable genes / PC count never doubted, never entered the multiverse). → The true target of anti-laundering. This is what Cairn's first principle (anti-laundering) is ultimately out to deal with, and also its most honest boundary: Cairn can put the "resistance" layer only on forks, contradictions, and confounds already declared by the agent; it cannot force the agent to doubt a never-doubted default. What it can do is lower the friction of declaring (one cheap add-claim writes down the fork condition) and surface unresolved contradictions and staleness on the orient surface, thereby widening the range of "what gets doubted"; but "an undeclared default" is the permanent ceiling of this mechanism — the same wall as ADR 0004's "the CLI enforces only consistency with declarations, never that declarations are true" (Part IV.2). Writing this entry into the mapping is itself resisting the laundering of "pretending this blind spot is solved."

Closing: no row in this mapping says "and therefore the tool judges the conclusion true / false." This is deliberate, and it is the spine of the whole book — Cairn is a judgment-free deterministic substrate. It persists the agent's judgments, mechanically enforces their consistency, and keeps a conclusion carrying its scars as it aggregates upstream (which fork it is conditioned on, what refuted it, whether it is stale, whether anything independent verified it). It never smooths those scars over for you. Smoothing the scars is laundering; surviving with the scars on is the one thing Cairn promises to do.

← Back to Writing