A mesh of agents decides by voting. Three of them are confidently wrong, and they are three of seven, so on a close call they carry it. Counting heads can't tell them from the four that know something.
Here, every vote comes with a stated confidence, and every decision is later confirmed right or wrong. An issuer signs each agent's record. Whoever relies on the vote checks that record, and weighs the vote by how often the agent has actually been right when it spoke that way.
The agent can't write its own score. The only way to change the record is to take part in a decision whose outcome is later confirmed.
Each agent names its answer and says how sure it is. The confidence is a prediction that will be checked, not a weight to be taken on trust.
answer + 0.82After the decision, the issuer confirms what happened. Each vote becomes one line in the agent's record: what it said, and whether it was right.
{c: 0.82, y: 1}The issuer signs a summary: the calibration error, and a table of how often the agent was right at each level of confidence. A Merkle root commits to the lines behind it.
CalAt: ece, dist, der.rootThe relying party checks the signature against the issuer's key, then recomputes the error from the table. It doesn't take the issuer's arithmetic on trust.
verify → recomputeA new vote at 0.9 counts for how often this agent has been right at 0.9. An agent that is calibrated but no better than a coin earns the floor.
0.9 → record → weightNothing is added to the signed object to do step 5. The weight is computed from what the attestation already carries.
Each run is 200 rounds of warm-up, in which records build up, and 200 scored rounds. The bars show how often the group got the right answer in that one run, under each way of counting. The line under them is the average over 200 runs, which is the number to trust.
This page checks the issuer's signature itself, with your browser's built-in cryptography, and recomputes the numbers from the signed table. It doesn't ask a server whether the attestation is valid.
A valid signature proves that the issuer's key signed exactly this record. It doesn't prove the outcomes in it happened, or that the issuer confirmed them honestly.
For the technically minded: the attestation is RFC 8785 canonical JSON with the sig member removed, signed with Ed25519. The issuer is a did:key, so its public key is in its name, and sig.kid must sit under iss. The demo's keys are derived from public labels and protect nothing.
sm-calat, and its benchmark. The attestation in section 03 is a real one: signed, and checkable.These open in the private repository, for people who have access to it.
The object, how it is signed and checked, and how a relying party turns it into a weight.
Why the record should be earned and not asserted, and what the first version of the idea got wrong.
Seven populations, eight rules, 200 seeded runs each. Includes the results that went against the design.
The reference library, 21 test vectors, and three checkers that don't import it.
The same stories in a terminal, the server behind this page, and how the page is built.
The agent registry work this attestation is meant to travel in.