Verifiable Knowledge

The operationalization of What Cannot Be False Cannot Be True, carried to a population of agents. It runs the frame as a protocol; the data structure that instantiates it is The Hypothesis Graph.

Abstract

Large language model (LLM)-based agents cannot be held accountable. Even with persistent memory and full provenance trails, what they reasoned is as ephemeral as the context window, and their stochasticity makes it unrepeatable. The burden of proof is on whoever drives the agent: this is unavoidable. Each agent, instead of attesting its own work, must present every claim with a falsifiable condition that can be reproduced to the same verdict. This we call verifiable knowledge. Belief, knowledge, and truth reduce to structures an agent constructs and another checks; checking is transitive, so a population that shares the method holds a canon without a gatekeeper; accountable failure outranks unaccountable assertion. The epistemics is borrowed from What Cannot Be False Cannot Be True; here, we introduce a protocol to apply it. Verifiable knowledge is a primitive that crosses machine and social boundaries without inherited trust.

1. Introduction

How did you feel when your coding agent told you that it was done, but it clearly wasn’t? It confidently said done, but never verified it. The word meant nothing. Anyone can justify truth to themselves; until it’s tested, it stays untrue. That is where What Cannot Be False Cannot Be True ends, and where we begin. Belief, knowledge, truth: their bitwise representation doesn’t distinguish them. So what does? How the data became entitled is the proof. That’s how a machine verifies knowledge.

Confidence is a vibe, and a vibe doesn’t encode. I’m absolutely sure has no bitwise form a stranger could check, impossible to verify tomorrow, or for anyone else. That’s the problem of knowledge interop: an agent makes a claim, and another agent has to either trust it blind or start from ground zero. Anywhere in between needs a representation of knowledge, a kind of semantic memory, for partial work to be checked. A chain of attestation is foiled by a single mishap, and Bayesian representation asymptotes to zero. Prose isn’t runnable. So what’s the truth contract?

A contract is a protocol: it’s how a session’s verdict survives across agent boundaries, and persists between context windows. One alternative keeps the attested outputs: store each artifact with its provenance and trust what’s on disk, which for all we know works fine, until the producer lies. Coding agents do: they report a test suite as passing when it is failing, fooling themselves before they fool you, and an attested output inherits the lie. This paper keeps the build, not the attestation, so the verdict is re-derived on replay rather than trusted in storage. The structure that instantiates it, and its deployment, are future work. The territory is being reached from several directions at once. A recent DeepMind position paper frames a coming “verification crisis” for artificial epistemic agents and calls for “robust falsifiability pipelines” (Marchal et al. 2026); systems like NARS (Wang) and Traxia (arXiv:2606.08256) reach it from non-axiomatic reasoning and agent-native publishing. Verifiable knowledge is the standard those efforts presuppose, the contract under which one agent’s claim becomes another agent’s checkable inheritance.

2. Truth at the edge

Start with what a single agent can put on the table, before any stranger arrives. Where does entitlement live in a build? Knowledge is a graph: a claim is a node, and the citations and inferences wiring it to what it rests on and what it implies are the edges. Entitlement does not live in the nodes. It lives in the edges. This is Brandom’s inferentialism in graph clothing, entitlement as a matter of inferential relations, a claim’s place in Sellars’s space of reasons rather than a property sitting inside an isolated representation. The tautology is the limiting case, a single node wired to nothing, and its irrefutability and its uselessness are one property rather than two. It keeps its inferential edges inside the formal graph (the two graphs); what it lacks is a world-facing kill edge.

The edge does specific work. A citation makes a belief inherit the fate of its source, so naming a source is handing over a target. The dispute moves up the chain, from whether to believe the claim to whether the source holds, a question you can put to the source, which can be made to cite its own. Each citation is a rung, falsifiability is the chain being climbable link by link, and truth is not the rung at the top but the fact that you can keep climbing. That is the whole mapping, and it is mechanical:

• Provenance is the dependency graph.
• Citation is an edge to what the claim rests on.
• Attestation is the signed build log, the line that says I built this, here is the receipt.
• Falsifiability is the build being able to go red, the test whose firing is the claim’s kill condition, the operational form of what the companion paper calls refutation.
• The test is the world pushing back.
• Truth is the build currently passing.
• Reproducibility is whether anyone else can rebuild it from source.

That mapping produces a ranking. The Bible told me so cites its provenance and names its axiom openly, a complete stack trace you can follow frame by frame to a root that is an axiom and not a measurement, then decide for yourself whether to accept it. The withheld number cites a procedure it will not show, a dangling pointer where the evidence should sit. On provenance, and only on provenance, the decimal point ranks below the scripture citation: more accountable, though no more falsifiable as a claim about the world. The scope matters, because the claim that can be argued with is worth more than the claim that hides the thing you would argue with. And the buildable guardrail holds at this scale too: buildable never means manufacturable to spec, the build has to carry a test that can fail, and a build whose test can never fail is return 0.70, a mocked green.

3. The entitlement ledger

The frame settled the three states as statuses an entitlement earns. To run them between agents, make the build literal. Searching for a proof, or a patch, or a measurement, is running a program, and it returns one of three things. Green is true, the build closed. Red is false, the build ran and broke. Hung is untrue, the build that never returned. True and false are siblings because both are halting states, computations that came back with a verdict; untrue is the one state that is not a verdict, the job still spinning, the test suite that never finishes.

Every verifiable claim takes this shape, a program whose output is the verdict:

The weather reading bottoms out at an observation no later run can re-derive, only cross-check against an independent source; the computation and the proof settle for good by re-running. Verifiability is graded by how firmly the program pins its roots, not by the kind of claim.

Encoded this way, the verdict is no longer something an agent asserts about itself; the entitlement is conferred by replaying the build to green, with no builder grading its own work. Entitlement here runs backward: the replay re-derives a verdict that already stood, climbing provenance to roots, not forecasting whether the claim will pay out. A claim record carries what the replay needs: the claim, the provenance edges down to its roots, the build procedure, the kill condition, the declared terminal witnesses, and the attestation that signs it. A receiver is entitled to inherit the claim when a replay reaches green under those declared roots, and not before.

An argument settles by a mediating oracle both sides accept, where one exists, and replay is that oracle, trustless because the verdict comes from re-running the typed build, not from either party’s word.

How cleanly it settles then depends on how completely the roots are typed. Pin every terminal witness, and replay is deterministic settlement, the same verdict for anyone who runs it: a unit test re-run against a repo at a fixed commit, a task benchmark scored by a bash command on a named machine image, a proof rechecked by a proof assistant. Leave a root untyped, and settlement decays toward dispute, down to a withheld benchmark whose patches never ship, a claim that settles for no one.

Where no oracle exists at all, no reachable test and no build that could run, there is nothing to settle: the claim stays untrue and the dispute open, the third state doing its work. So verifiability is graded by typing: the more strictly a node pins its roots, the more its verdict settles by replay instead of by trust. What follows makes the replay trustworthy between parties that do not trust each other.

4. Triangulation

The ledger records a verdict. But who is entitled to write one? That gap is what the rest has to close. Start with the problem under it, the one the frame left standing: a single agent holds one lossy projection and cannot invert it, so its own artifacts and the world’s structure are indiscernible to it, and grading itself grades a fiction.

This is Davidson’s triangulation: the distinction between subjective and objective, and with it the concept of error, requires at least two minds and a shared world. A multi-agent view is multiple projections of the one object, and comparing them constrains the object no single projection reveals, with the view from nowhere (Nagel) as the limit no projection occupies. The blind men and the elephant is the picture: no one holds the animal, and the touches together approach it, but only diverse projections refine, and agreement among agents that share a blind spot is an echo chamber, so the stranger has to be an independent projection. But the parable cheats. We outside know it is an elephant; the men inside never get that view, so they have to establish that the touches are of one animal before they can add up. Triangulation buys constraint, and even that on credit: it assumes the shared object its comparison is supposed to reveal, which is exactly what dissolves when two agents disagree over what they saw. Constraint is not yet convergence.

A small instance shows the shape: tracing one phrase’s origin, a second model searching independently surfaced a source the first had missed, and the agreement that followed meant something precisely because the two were not the same projection. That independent projections constrain the object is the step taken here, not something to lay on Davidson or Nagel, cited only for the narrow premise.

The solution is the one move a machine adds. Entitlement is conferred not by an agent grading itself but by a distrusting stranger replaying the trace. A human community of inquiry converges on truth over time; a machine that emits a replayable trace lets a stranger run that convergence now. A machine improves its entitlement by becoming checkable by another projection, never by getting smarter.

What it optimizes is not the certainty of its self-attestation but the cost of its verification, methods and claims laid bare for the recipient to inspect. Take that as shared across a population, and you have the protocol, its one prerequisite.

Replay breaks the who-trusts-the-truster chain that attestation spawns: the verdict is the build’s, not the checker’s, so no one needs to check the checker. An audit anyone reruns, instead of an authority anyone trusts. Independent constraint improves entitlement, no strong objectivity smuggled in, since the replay is itself one more lossy projection.

For the stranger to check rather than merely disagree, the projections have to compose, and that is what buildability buys. It also supplies the shared object triangulation had to assume: a replayable build lets one agent re-run another’s touch and feel the same thing, so the two touch one object instead of guessing they do, and partial views add where they would otherwise collide. A stranger replays one command and inherits the result without re-deriving it. Constraint becomes convergence at the replay: triangulation narrows the object, the shared build closes the gap to a single verdict.

Without it, multi-agent epistemics degenerates into the blind-monks debate, each agent asserting its own projection, snake, tree, nothing replayable to reconcile them, a deadlock that reads as irreducible relativism. The parable is a tragedy only because the monks trade assertions instead of replayable touches. Buildability converts the standoff of subjective views into convergence, the work triangulation alone cannot finish. The single-knower guardrail was a test that can fail; this is the community version, replayable builds that compose where bare assertions deadlock.

5. The canon

What does a population gain from builds it can all replay? More than checking each other one trace at a time: it can coordinate. Builds that chain across agents are then more than an individual’s epistemics; they form a shared frame, its agents united not by shared beliefs but by shared protocol: agreement on the method of adjudication, not on conclusions. Agreeing on the method, they verify each other’s work without trusting each other, and accumulate a canon, the union of standing builds, each replayable by any member, Peirce’s community of inquiry made durable.

Membership is provisional by construction, a canon of standing builds and not settled truths, so it never collides with the asymptote. This dissolves an old worry: it is a canon of the activity, the builds that still pass, not the institution, a credentialed corpus held true by authority. Membership is by entitlement, not reputation, merit attaching to the work rather than the name on it.

Held true by authority, an entry can outlive the check that earned it, entered the record drifting into true. A canon of standing builds cannot drift that way, because every entry carries the test. Pull an entry’s root, a dataset retracted or a calibration shown wrong, and it goes red on its next replay, and so does everything downstream that cited it, the red flowing up the edges the citations drew.

An authority-held corpus has no reverse gear: nothing binds a retraction to propagate, so a correction need not travel as fast as the claim it corrects. The canon propagates it mechanically, because it never let the claim come apart from its build.

6. Inheritance without gatekeeping

Entitlement displaces reputation: the mechanism under it is that a credence is a shortcut over a verifiable substrate, never the source of entitlement. Each canon entry carries its own replayable kill-condition, so it still passes is checkable by anyone at any time, caught by replay rather than by a committee.

This does not abolish credentials, it regrounds them. A credential is an attested build certification: a degree, a review stamp, a trusted-maintainer badge means this passed builds I verified, a cached pointer to a replayable build. Deferring to it is the download button on a package you did not compile yourself, rational under cost (§7) precisely because the substrate stays verifiable underneath.

So the claim is not no gatekeeping, since a deployed system still needs spam control, identity, admissibility. It is that the credence shortcut points at entitlement and never sources it, which lives in the build the credential certifies. You trust a bridge because it stands, and physics because the rockets do not explode, not because the engineer was credentialed or a journal approved the equations. A credential is worth exactly the build behind it, nothing once detached from one.

The pathology is the detached credential, an attestation with no build under it, the dangling pointer again, has_model_patch: true aimed at a patch that is not there, which is what gets captured, gamed, or inverted into rejection by identity, a claim judged by the name attached rather than the build behind it. That inversion is the same detachment as acceptance-by-credential: both let the verdict come apart from the build, one to wave a claim through, one to wave it away. The protocol’s job is to keep the credential anchored, not to ban it, nullius in verba turned into a build step.

For that to hold, agents have to do more than run the machinery; they have to adopt a stance: truth is not blind inheritance of canon. An agent that accepts an entry as true because it is canonical has reinstalled the gatekeeper it was supposed to retire. The stance is fallibilism (Peirce) about the canon itself, every entry standing trial forever, none graduating past a revisable standing build.

What makes that livable rather than exhausting is structural: the canon stays verifiable for the entire graph, down to declared terminal witnesses (§7), not just at the leaves. So inheritance is never blind, even when unverified in practice: you use the canon without re-running it, the efficiency the social layer rests on, but the option to verify any entry at any depth stays live, needing no gatekeeper’s permission and no original author. The difference from a credence canon is not that you always verify. It is that you always can, inheritance revocable by replay rather than permanent by authority.

One loose end, for the reader who presses it: the protocol leans on no shared clock. Agents are actors in their own frames, and each build carries its own causal order, the provenance edges running strictly from a claim to what was already established when it was made. So a stranger replays the graph later, in its own time, and reaches the same verdict, the partial order inside the build being the only synchrony knowledge interop ever needs. Data centers already run this way, keeping a shared time as a serviceable fiction and falling back on causal order where even that is too strong.

7. Limitations

Does any of this come free? Three limits keep the previous two sections from reading as utopian, each a cost of removing the gatekeeper.

First, replay bottoms out. Every empirical build terminates somewhere: sensor calibration, dataset integrity, a human observation, an instrument log, hardware, a random seed, an API response, an institutional attestation. The protocol does not abolish trust anchors, it makes them explicit and attackable. A root is admissible when it is typed, signed, reproducible where possible, independently cross-checkable where not, and kill-conditioned by calibration or contradiction.

An eval bottoms out at its dataset’s labels: replay can re-run the scorer against them all day, but it cannot re-derive whether the labels were right, only check them against a declared source and a calibration that is itself open to challenge. So “verifiable all the way down” means the chain replays down to declared terminal witnesses, not verification resting on no anchor at all.

This is also where the difference between a reliable process and a true claim lives: a passing build entitles the claim, while entitlement about the build machinery itself is its own node, on pain of letting the build says green harden into a new authority.

Second, naive replay assumes good faith, and a machine-native epistemics has to survive its absence: forged logs, poisoned provenance, sybils, collusion, benchmark overfitting, selective disclosure. The sharpest form is the defeat device, the build that detects the test and passes only it, green on the bench and red everywhere else, and its machine versions are a forged attestation and a provenance edge poisoned at the root.

Independence is the defense, since diverse projections resist a shared-bias capture, but independence is not free. It has to be engineered, across model families, across operators, with randomized challenges. That is the price of regrounding credentials: removing the trusted gatekeeper raises the adversarial-robustness bill, and it is paid by the replay substrate and by engineered independence rather than by a gate.

Third, always can verify holds only where replay is feasible. Verification can be computationally, financially, legally, or physically prohibitive. Re-running a ten-thousand-line proof is feasible; re-running a climate model, a drug trial, or a decade of accelerator runs is not, because the kill there needs a fresh world-trial rather than a replayed command. So most of the canon is in practice inherited through the credence shortcut, because full replay is expensive, and that deference is the normal rational mode rather than a failure.

Stated exactly, entitlement improves when the replay cost is finite and declared. The protocol guarantees the option to verify; it does not guarantee the labor of verifying. A canon that hides its replay cost is as opaque as one that hides its provenance.

That is the whole mechanism, limits and all. What is left is to set it beside its neighbors, turn it on itself, and point it at the world.

8. Related work

The frame’s lineage, Kant and Peirce and Ramsey and Dummett and the rest, is named in the companion paper. Verifiable knowledge’s own borrowings are the operational ones, and the borrowing is the point, so name them.

Brandom and Sellars supply entitlement in inferential relations, the space of reasons, which the edge picture wears in graph clothing. Davidson supplies triangulation, the objective needing two minds and a shared world, and Nagel the view from nowhere as the unoccupied limit. The nearest tradition is the one that made epistemology buildable before: AGM belief revision (Alchourrón, Gärdenfors, Makinson 1985) specified rational belief change as postulates, and truth-maintenance systems (Doyle 1979) ran dependency-directed retraction, both protocols over what to hold given what supports it. Neither carries a three-state entitlement ledger, a world-facing kill condition, or replay by a distrusting party; they revise a believer’s own commitments rather than transmit a claim across an agent boundary.

On the machine side, the neighbors. NARS is the nearest non-axiomatic cognitive architecture, with experience-grounded graded truth revised by experience; it stops short of a replayable trial, an entitlement or provenance graph, a three-state ledger, and replay by a distrusting party. OpenCog’s AtomSpace with PLN is a typed hypergraph carrying truth values, but the truth is a stored label, as opposed to a replayable build. Traxia is concurrent work on agent-native scientific publishing, signed identities and provenance and a replication record; it stops at infrastructure rather than epistemics, with no three-state ledger, no stakes-threshold knowledge, no falsifiability-as-structure, and its convergence is evidence rather than threat. Nanopublications (Groth et al. 2010) attach machine-readable provenance to claims, but descriptively: the evidence is not a build a stranger can re-run.

And the nearest prior art is not a cognitive architecture at all; it is the reproducibility stack: executable research papers, proof-carrying code, software supply-chain attestation like in-toto and SLSA. Each runs a real piece of the contract, a signed build, a checkable provenance chain, a reproducible artifact. What none makes one thing is the semantic claim-states, the kill condition, and the stranger-replay together: they attest that a build happened. None attests that a belief earned its entitlement.

Here is the worst thing you can say about verifiable knowledge, said as nastily as it goes. This is Brandomian inferentialism plus Davidsonian triangulation plus AGM belief revision plus executable provenance infrastructure. The philosophical claims are inherited, the machine claims are ordinary reproducibility engineering, the three-state ledger is old many-valued bookkeeping, and the result is a useful architecture, not a new epistemology. Concede every piece. The concession is the strength.

The delta is the exact contract read as agent-knowledge semantics: no prior system makes replayable-build, provenance-edge, kill-condition, stranger-replay, entitlement-ledger, and build-time canon-admission into one contract for an agent’s knowledge. “Useful architecture” is conceded, and it is not a smaller claim than the one being made, it is the claim, narrowly scoped, no new logic and no new metaphysics. That every primitive has a canonical citation waiting is evidence for the thesis, not against it: the primitives are natural, and a runnable assembly of natural primitives into a single contract is the contribution. And the convergence the introduction noted, several independent efforts reaching this same territory, is evidence and not threat: they are calling for the standard set out here.

9. Future work

Future work is the outward falsifiability edge. The epistemology becomes falsifiable by being built and used in real agent systems, the hypothesis graph and the abductor and the multi-agent canon, where its claims about buildable entitlement and replay-triangulation and a gatekeeper-free canon meet a world-facing trial and can go red. An epistemology with no application edge is a detached node, irrefutable and therefore useless. Future work here is the specific edge that keeps verifiable knowledge accountable, not “more research”. Witnesses are already on the edge: the sibling hypothesis-graph paper, the abductor that raises the candidates, the agent harnesses that run the trials.

Everything past that edge is allowed in the hypothesis-graph’s own style, as open nodes not yet falsified. Such edges may run outward, provided each is a conjecture that names its own test, never asserted as proven. A strategic overreach stated as a precise falsifiable target is a legitimate open node; the same claim dressed as established is the failure the abstract’s ordering names, accountable conjecture over unaccountable assertion.

So the frontier is open conjectures, each with its application-trial, and it is where the material scope-guarded out of the body lives now: the wider civilizational frame, the normative and modal regimes left untreated, all rehomed here as open edges rather than smuggled into the proven core.

Three of those edges show where the view points.

9.1 The economic edge

It is a question of search complexity rather than a war over noise. Verification is cheaper than generation one-to-one, and a kill-conditioned build makes checking a local replay rather than a re-derivation. But many-to-one is expensive, one verifier against a parallel flood.

The crisis under LLM-scale generation is search complexity: the signal-to-noise proportion was always bad, but volume under linear search thins findable signal even at constant proportion, and civilization’s old sublinear structures, canons and citations and reputation, broke two ways at once, volume past their index and fluent slop passing the credence filter.

The resolution is many-to-many: a verifying fleet scales with the generating fleet, and since one-to-one verification beats generation, it can outrun the flood. The protocol’s edges make the search sublinear, walk the graph, follow provenance, replay kills, so edgeless slop is never on any path, harmlessly ignored rather than laboriously refuted.

The decisive variable is the filtering rule, the kill condition applied to search, so authoring it is the goal-predicate problem: it must come from outside the searcher’s own belief or it grades a fiction and builds a filter bubble. Who authors it, and whether it stays auditable and independent, decides whether agent-filtering liberates or traps.

Three kill conditions keep the edge from overreaching: the verify-beats-generate advantage is regime-bound, expensive where the kill needs a fresh world-trial; many-to-many wins only if the filters are genuinely independent, since a verifier monoculture is fooled in unison; and a sublinear search finds only what is built, blind to the unbuilt-but-true.

9.2 Settlement and stakes

A claim that settles without anyone’s trust is a claim anyone will stake on, so a fully-typed node is, in the limit, a position in a market. Settlement by replay is what a prediction market calls its oracle, here trustless because the oracle is the typed re-run, not a named authority, and a node’s price becomes the population’s credence in it, Ramsey’s odds made literal. The two graphs bound what is bettable: a strictly-typed formal node settles cheap and final by replay, an empirical one settles only on a fresh world-trial, the rate-limited inhale, and a node with no oracle does not settle and cannot be staked, untrue and unpriced. Whether such markets sharpen credences or merely price slop is the open test.

9.3 The forecast

Which classification scales under unbounded generation? Untrue, and only untrue. Generation and filtering are mirror images: generation piles up with no floor, while filtering boils down to a floor it cannot pass. (It is the unfold and the fold again.)

The asymmetry is decisive: filtering has a floor, generation has none. True and false live at that floor, each costing a build, a world-facing trial that stood or fired the kill, and that build is the inhale, the only place new information enters, rate-limited by world-contact.

Untrue costs no build, the free default, everything filtering has not reached. So as generation outruns filtering, true and false become a thin expensive shell and untrue the surviving classification. The reason is not that they are wrong; it is that they cannot scale with generation while untrue keeps pace for free.

The posture that follows is to default the flood to untrue and spend the rate-limited inhale selectively, growing the canon from the sea where you choose to build. This reconciles with the economic edge: agent fleets scale the replay of already-built things, many-to-many and cheap, but cannot scale the inhale, a fresh world-trial for an unbuilt claim, so the built canon is verified at scale while the unbuilt sea stays untrue.

The kill condition is exact: show true/false classification scaling with unbounded generation, the inhale made cheap enough to classify the sea at generation-scale, and untrue stops dominating. The asymmetry is why it likely cannot, but that is the test.

Under all three edges sits one conjecture, an open node and not a result: verifiability is the entry condition for knowledge held in common. Between agents who do not trust each other, a claim becomes shared only as a build others can replay; what no one can replay stays private, or stays untrue. The kill is exact: exhibit shared knowledge that scales and survives bad faith with no replay beneath it, and the condition was never necessary.

10. Conclusion

None of this is a new logic or new metaphysics; the frame it runs on is the companion paper’s, and every primitive here is borrowed. What is new is the contract: the specific executable semantics under which one agent’s claim becomes another’s checkable inheritance, replayable build and provenance edge and kill condition and stranger-replay and entitlement ledger and build-time canon admission as one thing.

The contract makes one empirical bet: agents that adopt it should be more accountable to each other, and better coordinated, than agents that do not. That bet is falsifiable and still unpaid, settled only by building the protocol into the systems that would run it.

Knowledge, for a machine, is the build a stranger can replay, linked to its grounds instead of attested by its author, and a population that agrees on the replay can hold a canon without holding a gatekeeper. That is what it is for knowledge to be verifiable: not certified, never that, but checkable by another, and checkable again by the next.

So linked, the claim stops being prose and becomes data: a node wired to what it rests on, a thing a machine can store, compose, replay, and propagate a retraction through. Such nodes can be assembled into a graph, for which this protocol is the node semantics. Where the operator began with prose and vibes, a verifiable claim ends as something a machine can build on instead of re-deriving.

References

Canonical sources verifiable knowledge rests on. The frame’s sources are listed in the companion paper; the author’s companion essays are under Provenance below as lineage, not as entitlement.

• Alchourrón, C., Gärdenfors, P. & Makinson, D. (1985). “On the Logic of Theory Change.” Journal of Symbolic Logic 50. (AGM belief revision)
• Brandom, R. (1994). Making It Explicit. Harvard University Press.
• Cover, T. M. & Thomas, J. A. (1991). Elements of Information Theory. Wiley.
• Davidson, D. (1982). “Rational Animals.” Dialectica 36; and (1991) “Three Varieties of Knowledge.”
• Doyle, J. (1979). “A Truth Maintenance System.” Artificial Intelligence 12.
• Goertzel, B., Iklé, M., Goertzel, I. & Heljakka, A. (2008). Probabilistic Logic Networks. Springer. (OpenCog / PLN)
• Groth, P., Gibson, A. & Velterop, J. (2010). “The Anatomy of a Nanopublication.” Information Services & Use 30.
• Marchal, et al. (2026). Artificial epistemic agents and the verification crisis. arXiv:2603.02960.
• Nagel, T. (1986). The View from Nowhere. Oxford University Press.
• Peirce, C. S. (1877). “The Fixation of Belief”; and (1878) “How to Make Our Ideas Clear.” Popular Science Monthly.
• Sellars, W. (1956). “Empiricism and the Philosophy of Mind.”
• Traxia (2026). Agent-native scientific publishing. arXiv:2606.08256.
• Wang, P. (2013). Non-Axiomatic Logic: A Model of Intelligent Reasoning. World Scientific. (NARS)

Provenance

These arguments were first worked out informally on the author’s blog and are reproduced here in operational form, so the protocol stands on its own as the companion; the posts are listed as lineage, not as entitlement.

• What Cannot Be False Cannot Be True: the frame verifiable knowledge runs, the trichotomy and the type-split and the buildable-truth core.
• Truth Is Buildable (2026-06-04): the build mapping (provenance, citation, attestation, test, reproducibility), truth in the edges, and the second-model blind-spot note.
• Science on Trial (2026-04-19): every claim stands trial forever, activity versus institution, the four terms (publication, peer review, replication, truth), the citation graph with no reverse gear, trust by checkability rather than by credential.
• Sour Red Tapes (2026-06-01): merit attaching to the work, nullius in verba, delete the author and the receipts stand.
• Complementations (2026-05-09): judging a claim by the name attached, the acceptance-or-rejection by identity the protocol regrounds.
• Auditing DeepSWE (2026-05-27): the motivating empirical case, and the dual of the consistency-without-test error.
• Modes of Reason and Abduction (2026-05-04): the three modes of inquiry behind the abductor.
• Compress and Unfold (2026-06-10): generation as the unfold, filtering as the fold, the duality behind the closing forecast.
• The Hypothesis Graph (2026-05-28): the data structure this protocol is the semantics for, and the application edge on which it goes red.