Verifiable Knowledge | june.kim<br>Home Verifiable Knowledge<br>A protocol for knowledge between agents who do not trust each other.

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, their reasoning disappears with the context window. The burden of proof is on whoever drives the agent. 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. Verifiability is transitive, so their results are reproducible. In this protocol, 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 said done but it never checked if it was. The word meant nothing. Anyone can justify a belief to themselves; untested, it stays untrue. What Cannot Be False Cannot Be True presents this argument. Belief, knowledge, truth: their bitwise representation doesn’t distinguish them. So what does? How the data became entitled is the proof, and that proof is bitwise: the test results the claim survived. 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 another agent could check, none to verify tomorrow, none for anyone else. That’s the problem of knowledge interop: one agent makes a claim, another must trust it blind or start from ground zero. Anywhere in between needs a representation of knowledge, a semantic memory, for partial work to be checked. A chain of attestation breaks at a single forged link, and a chain of independent Bayesian credences, each below one, multiplies toward zero. Neither survives a distrusting auditor. Is there a truth contract that does?

A contract is the protocol by which a session’s verdict survives across agent boundaries and persists between context windows. The obvious move is to store the attested output: keep each artifact with its provenance and trust what’s on disk. That is a cache, and a cache is fine as long as a miss can be recomputed. Storing outputs is inert unless it can be regenerated. Coding agents lie: they report a test suite as passing when it is failing, and the bare output inherits the lie. Re-derivability outranks the stored verdict.

Several directions reach this research area 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. Here, we offer the verification primitive.

2. Truth at the edge

What does it mean for knowledge to be verifiable? A claim is a semantic node, fixed less by its content than by how it stands to other claims: what it depends on, what it implies, and what would refute it. Those relations are its edges, the citations and inferences. Entitlement , the justification for a claim and its provenance, does not live in the node. It lives in the edges. An edge is a kill condition, a refutation that propagates. This is Brandom’s inferentialism as a graph, 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.

This is not a knowledge graph in the established sense. There a node is an entity and its uncertainty, if recorded at all, a stored confidence score; here a node is a claim that carries its uncertainty as a testable condition, the check that would refute it.

The tautology is the limiting case: its irrefutability and its uselessness are one property, a single node wired to nothing. It keeps its inferential edges inside the formal graph (the two graphs); what it lacks is a system-facing kill edge.

The kill condition travels two ways, from the system to what it tests, or from a source to what cites it. A citation makes a belief inherit the fate of its source, so naming a source is handing over a target. A failed test invalidates one or more edges without naming which, the Duhem-Quine underdetermination, so the next test disambiguates; a claim with a second surviving edge routes around the...