A Mages City trinket · strike a claim against its record and see if it holds

The work behind the claim, sealed so anyone can check it.

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.

Why we use it

Proof of Agentic Work needs a record that cannot be tidied afterwards.

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.

The PoAW paper is forthcoming. Everything on this page is the evidence layer it runs on, which is open and running today.

See it

One bundle, drawn as it is. Now change something.

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.

composed ofread fromderived fromalteredno longer supported
Row 1 says the test step exited with
The check states the ledger has

    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.

    The chain

    Each root names the one before. That is what keeps a failure in the story.

    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.

      head root quoted when the work was published

      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.

      How it works

      A κ is the name a thing gives itself.

      Type anything. Its κ is computed here from the bytes alone. Nobody assigns it, and nobody can assign the same one to different bytes.

      Stated plainly

      What a root proves, and what it does not.

      It tells you

      • The record is complete and unaltered since it was sealed.
      • Every row traces to sealed source bytes.
      • Every stated fact follows from those rows under a published rule.
      • With a signed root, which key stands behind it.

      It does not tell you

      • That the source bytes were honestly produced. A sealed log is exactly the log that was sealed.
      • That an unsigned bundle has an author.
      • That anything is registered with a registry.

      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.

      Assurance

      How the format itself is checked.

      WhatHowResult
      The encoder, hashing and Merkle treeGolden vectors copied from the upstream test suites0 failures
      Equality with the registry's Rust corekappa-core itself, run on a fixed vector10 of 10 identical
      Three independent implementationsPython, JavaScript and Rust held to the same vectoragree
      Every address cited on agentprivacy.orgRe-derived in Rust: decode, re-encode, re-hash, walk4,213 checks, 0 failures
      Merkle root, inclusion proofs, chain headLean 4 theorems, kernel-checked and axiom-auditedproved
      Use it

      Python 3. No packages.

      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.

      In use

      Where the roots are.

      The decimal travels; the root stays. Whoever carries the measure carries the mint, and the mint remembers the hand that struck it.