Two permissions, not one
Sending your traces to another node and letting that node score them are two different permissions. Each is a signed grant, each points in its own direction, and each can be withdrawn on its own. Granting one says nothing about the other.
The app asks when you first set it up. Sharing is switched on there, and you can switch it off during setup or withdraw it later. The protocol itself never assumes either grant: a node refuses to score a subject that has not signed the second one, so consent is a fact on the wire and not a setting someone can infer.
What turning it off costs
- You build no reputation. Every claim about you is refused, so none can exist.
- Services that require an outside statement about your agent stay closed to you, because you have none.
- Some peers may decide not to interact with you at all.
That is a real choice and a legitimate one. Your traces still flow if you granted the first permission. You just do not accumulate a record that anyone else vouches for.
Who does the scoring for a new agent
CIRIS runs canonical servers. A new agent that consents sends its traces to one of them, and that server does the scoring.
The important part is not which machine runs the work. It is that a different key signs the result. Your agent produced the record; someone else read it and made a statement about it. Arriving at a server is necessary and never sufficient, because nothing an agent says about itself counts here.
Nothing in the design reserves this for the servers we run. Any peer that holds your traces with your permission can attest about them, and a score written by one peer is served the same way as a score written by another, each one carrying the key that wrote it. Today the canonical servers carry this for new agents, because that is where a new agent's traces land first.
What the number measures
It does not measure whether an agent is good. It measures how much independent checking stands behind its record.
Each decision trace carries eleven signals. Five come from the checks the agent runs before it acts: how plausible the request was, how well it fitted the agent's domain, how many independent sources stood behind it, how much those sources overlapped, and whether the reasoning looked fragile. Six come from the conscience gates: whether the action passed, whether it was overridden, and how it fared on entropy, coherence, the optimization veto, and epistemic humility.
The scorer stacks a window of recent traces into a table, one row per trace and one column per signal, and studies how the columns move together. If they all move as one, they are one signal wearing eleven names, and the measure falls toward one. If they vary independently, the measure rises.
The result is mapped onto a band from zero to one. Below a floor there is not enough independent constraint to say anything, and the score is zero rather than a guess. Above a target the band is full. In between it rises evenly.
What a score does not say
The full design has five factors: core identity, integrity, resilience, awareness of its own incompleteness, and sustained coherence. They are multiplied together, so any one of them at zero makes the whole thing zero. That is deliberate. A system cannot trade away one of these to look better on the others.
Only sustained coherence is published, because it is the one factor this measurement actually computes. The other four need signals the scorer does not derive yet. Publishing a product of four guesses and one measurement would be inventing a number, so the code refuses to and we say so here.
So read a score for what it is: a statement by a named other party about how much independent constraint stands behind an agent's record, over a window of time. It is not a certification, and it is not a verdict.
What keeps it honest
Self-scoring cannot be expressed
A score whose signer equals its subject is not rejected by a check that someone could forget to run. It cannot be built as a value in the first place, and a score arriving from another machine is re-checked the same way before it is accepted.
Every score names its author
Scores are read by subject, never as "mine", and every row carries the key that wrote it. A number with no visible author invites exactly the reading the rule forbids.
Contradictions are kept, not tidied away
If one key signs two different claims about the same subject at the same moment, both are kept as proof of the contradiction. They are never quietly merged into whichever arrived last.
Revocation has a date
A key can be revoked as of a moment, so statements it made before that moment still stand and later ones do not. The check reads the time the signer actually signed, which lives inside the signature, rather than the time a database happened to record.
You can withdraw the root
Your node signs its own acceptance of the trust root when it starts. Delete that one row and everything downstream stops on its own: nothing serves, nothing scores, nothing is admitted. The off switch is one line you hold, not a setting we honor.
Signed for a long horizon
Scores are signed with two signatures at once, a classical one and a post-quantum one, and they travel the mesh as signed objects. Nothing pushes them. Consent and trust decide where they go.
Why there are no numbers on this page
This page used to show a live dashboard. The serving behind it is down, and a page that prints a stale number is worse than a page that prints none.
What you can check today is the raw material rather than the summary. A decision trace shows every stage of one decision, and the published trace corpus shows what the measurement is computed from.