An agent reports a result. κ evidence is everything that stands behind it: each proposal, test and verdict, the failures too, named by the hash of its own bytes and tied into one root. It is the record that Proof of Agentic Work is made of.
When agents do research, what travels is the headline: a score, a bound, a sentence saying it worked. The attempts that failed, the tests that were run and the order things happened in stay behind with whoever ran the agents. Proof of Agentic Work (PoAW) is our discipline for publishing the work itself, in a form a stranger can re-derive. It asks five things of its record. Each one is a property of this format.
Everything is named by the hash of its bytes. Verifying needs the bundle and SHA-256: no service, no account, nobody to ask.
A stated fact names a published rule. The verifier runs the rule over the sealed rows and requires the same answer, byte for byte.
A refuted attempt is a leaf like any other. The root commits to it, and the next root commits to that root, so it cannot be dropped later without breaking every root after it.
A proposal is sealed first. The tests it faces are drawn from its κ, and the draw is itself a record in the bundle that the verifier checks against the proposal.
A bundle is minted and verified before the result is submitted, and the submission quotes the root. The number may be copied anywhere. The root says where it came from.
The PoAW paper is forthcoming. Everything on this page is the evidence layer it runs on, which is open and running today.
This is the example bundle from the repository: a source file, three rows read from it, a ledger, a check and a root. Select a node to read it. Then alter the work and watch where the damage goes: it always reaches the root.
The verifier runs on this page with Web Crypto; nothing leaves it. It follows the reference procedure: re-hash every item, walk the links, recompute the check, recompute the Merkle root. The reference verifier also recomputes a BLAKE3 label for every item and scans for private paths, which this page leaves out.
A line of research is a chain of bundles. Here are four steps of one, with an attempt at step 2 that was refuted. Suppose someone later prefers that it had never happened, and rewrites it.
A sketch with real hashes: each root here is the κ of a small object holding the step, its verdict and the previous root. A real step is a full bundle like the one above, and the chain verifier checks every bundle as well as every link.
Type anything. Its κ is computed here from the bytes alone. Nobody assigns it, and nobody can assign the same one to different bytes.
A file is stored under sha256: of its content. A structured object is first written in deterministic CBOR, which gives it exactly one byte form, and is then named the same way.
A row of evidence carries a typed link to the sealed file it was read from. A row with no source in the bundle does not verify.
A fact that the verifier cannot recompute from sealed bytes under a published rule is not accepted. An unknown rule fails.
The root commits to every name in the bundle through a Merkle tree, and may name the root before it. Quoting one root is quoting the whole history behind it.
Rules can close the first gap where the work allows it. A rule may re-run a proof verifier on the sealed proof, so its fact is recomputed truth and not a recorded verdict.
| What | How | Result |
|---|---|---|
| The encoder, hashing and Merkle tree | Golden vectors copied from the upstream test suites | 0 failures |
| Equality with the registry's Rust core | kappa-core itself, run on a fixed vector | 10 of 10 identical |
| Three independent implementations | Python, JavaScript and Rust held to the same vector | agree |
| Every address cited on agentprivacy.org | Re-derived in Rust: decode, re-encode, re-hash, walk | 4,213 checks, 0 failures |
| Merkle root, inclusion proofs, chain head | Lean 4 theorems, kernel-checked and axiom-audited | proved |
The core, the minter and the verifier run on the standard library alone, so everything a verification depends on can be read in an afternoon.
# get it git clone https://github.com/mitchuski/kappa-evidence-mage cd kappa-evidence-mage # mint the example bundle, then re-derive it from its root python example_mint.py python verify_bundle.py out/example # or from your own code python -c "import kappa as K; print(K.kappa_from_value({0: 'example/thing/1', 1: 'hello'}))"
To seal your own work, write one thin adapter: put each source file as a blob, each row as a record, state the facts as checks, and call the root. The example is the whole pattern in thirty lines.
The decimal travels; the root stays. Whoever carries the measure carries the mint, and the mint remembers the hand that struck it.