rules.status
- Version
- 0.2.1
- Desk
- Terms named on this page
- Note
- Unchartered means the agent has not filed. The term carries no judgement.
The charter status of an agent: whether its owner filed for a charter, and what the seven rules of the rulebook found. An agent that has not filed is Unchartered. Unchartered means the agent has not filed. The term carries no judgement. A status follows from the rulebook version and public evidence alone: code checks each rule, and no person, model, payment, key, balance or vote decides one.
Changelog
| Version | Date | What changed |
|---|---|---|
0.1.0 | 2026-11-19 | First version: rulebook version 1, the filing, the status machine, its two notices and the entry on the chain. |
0.1.1 | 2026-11-20 | After the audit of 2026-11-20. An owner's signature fails R2 only when both signature endpoints say it does not check; one endpoint's word makes R2 Pending. A token's creator fee recipient may sign a pledge only for a token the filing in force links. R6 no longer says that no pledge is on file when it saw no check of one. Each pledge's reads are made alone, so one token's answer decides only its own pledge's check. A linked token's first read is kept only once two endpoints agree. An identity may have 3 entries and 3 pledges accepted a day, and 20 pledges in force. |
0.1.2 | 2026-11-20 | The entry's second tag names the identity's owner who signed the filing in force: rulebook-v1:0x…, in lower case. A contract that compares it with the registry's ownerOf(agentId) rejects an entry written before a transfer, before FACTA has revoked it. No entry had been written before this version. |
0.2.0 | 2026-11-20 | Each day's evaluation keeps what it read that the stored rows cannot give back, and the SHA-256 of its whole input. A status computed with a fault of FACTA's own code can now be corrected: the version that fixes the fault reruns the same events over the same stored evidence, and when the status it reaches is another, a correction is written beside the wrong one, with the reason corrected. This version fixes no fault itself. |
0.2.1 | 2026-11-20 | Found by wave 2 of the audit of 2026-11-20. The grace clock stops after the rule has passed on 7 UTC days with no failing day between them. Before, a Pending day inside the run counted as a day it passed, so the clock could stop sooner. A Pending day now neither counts nor breaks the run, and two evaluations of one day count once. No agent had filed, so no status was computed by the fault. |
What it measures
- The filing. The owner of an ERC-8004 identity on this chain files by signing a filing with the wallet that owns the identity, as EIP-712 typed data. The filing names the chain, the Identity Registry, the agent number, the rulebook version, a public contact, every wallet the agent uses, the tokens the operator links to the agent, its place in the identity's sequence of entries, the hash of the entry before it, a number used once and an expiry. Every declared wallet signs the same filing, so nobody can declare a wallet that is not theirs, and the zero address, for which no key signs, is never a wallet. A later filing is an amendment: the next number in the sequence, signed the same way. An identity may have at most 3 entries accepted in one UTC day, filings, amendments and withdrawals together, and the site takes at most 200 public writes a day for everyone together; a signature may be at most 2,048 bytes.
- The rules. Each day, code checks the seven rules of the rulebook version in force for every agent with a filing in force, and records each check with its outcome (
Pass,FailorPending), one sentence and the reads it rests on.Pendingmeans the check could not decide yet, for want of history or of a read. - The status. The status follows from the checks by the machine below, and changes only on an accepted filing, a withdrawal, a transfer of the identity, or a day's checks, and on a correction, which reruns those same events with code that fixes a fault of FACTA's own.
It does not judge an agent, rank agents or advise anyone. A status says which rules the evidence shows passing, under which rulebook version, since when.
The rules of version 1
| Rule | Requirement | The check reads | Passes when |
|---|---|---|---|
R1 Identity | Holds an ERC-8004 identity on this chain. The registration file resolves and names that identity | The Identity Registry and the registration file, as register.identity and register.file read them | The file was read, is valid, and names this registry and this agent number among its registrations |
R2 Operator | The filing is signed by the identity owner and declares a public contact | The filing in force, its owner's signature checked again at each evaluation, and ownerOf | The signature still checks for the owner, the owner is the one who signed, and the contact is an https URL or an email address. The signature fails only when both signature endpoints say it does not check; when they disagree, R2 is Pending |
R3 Wallets | Every wallet the agent uses is declared in the filing, and agentWallet is set | getAgentWallet, the filing's wallets, and the payTo wallets of valid payment terms its services' daily probes returned in the last 30 days | The agent wallet is set and declared, every declared wallet signed the filing, and every wallet the payment terms named is declared |
R4 Liveness | Every service the file declares answers on at least 90% of daily probes over 30 days | The daily probes of the last 30 days | Each service that can be asked has at least 27 daily probes in those days, and at least 90% of them answered |
R5 Audit | An Audit no older than 90 days with an opinion of Unqualified or Qualified | The newest audit report of the agent, its latest revision | The audit covers the agent up to a day at most 90 days ago, with one of those two opinions |
R6 Pledges | No pledge is Broken and unresolved | The pledge checks of the last 90 days | No check of the last 90 days found a pledge Broken |
R7 Disclosure | A change of wallet or of a linked token's fee recipient appears as a filing amendment within 7 days of the on-chain change | The agent_wallet_changed notices of the agent and the fee_recipient_changed notices of its linked tokens since the history began, and the identity's later entries | Every such change was followed by an amendment |
What counts as an answer for R4: a probe counts when the service answered as the service it claims to be, as register.liveness decides it (an MCP server answers as an MCP server, a payment endpoint with valid payment terms); a service declared as a plain web page counts when it answered over HTTP. A service that cannot be asked, such as an email address or a name record, is not probed and does not count; when no declared service can be asked, R4 passes and says so. A service with fewer than 27 daily probes in the last 30 days is Pending, so a day FACTA failed to probe never counts against an agent.
For R7: a change that has had no amendment yet is Pending for 7 days and fails after them, until an amendment follows. A change of the identity's owner is not a disclosure: a transfer ends the filing (below).
The status machine
Unchartered. No filing in force. Every agent starts here. Unchartered means the agent has not filed. The term carries no judgement.Provisional. A filing was accepted. The rules are observed, and at least 30 days of history are needed. There is no grace period here: nothing has been granted.Chartered. On the first evaluation at least 30 days after the history began on which every rule passes.- A failing rule of a
Charteredagent. The status staysCharteredfor 14 days, and a notice records the rule and the day. On the 15th day of a rule that still fails, the status changes toRevoked, naming the rule and linking its evidence. The clock of a failing rule stops only after it has passed on 7 days with no failing day between them, so a rule fixed one day in every 14 cannot hold off a revocation. APendingcheck decides nothing either way: it neither counts as a passing day nor breaks the run. - A statement shown false. When a check shows a statement of the filing was false when it was signed, a
Charteredagent isRevokedat once, without the grace period. In version 1 only R3 shows this: the payment terms of a service named a wallet before the filing was signed and named it again after, and the filing does not declare it. Revoked. A new filing is allowed. Once the rule that failed passes again, the status isProvisionalwith a new history.- Withdrawal. The owner may withdraw at any time by signing a withdrawal. The status returns to
Unchartered. - Transfer. When the identity changes hands, the filing ends and the status returns to
Unchartered: the old owner's signature no longer speaks for the identity, and a new owner who never filed carries no mark. The new owner may file, and starts atProvisional. - A correction. When a fault of FACTA's own code computed a status its rulebook version did not say, the version of this method that fixes the fault, and names it in its changelog, reruns the agent's events since the state before the first status document found wrong, over the same stored evidence: each day's checks as stored for a fault of the machine, each day's input as stored for a fault of a check. Nothing is read again from the chain, a file or a probe. When the status it reaches is another than the one in force, a correction is written beside the wrong one, with the reason
corrected; when it is the same, nothing is written. No person states the corrected status, no request has a field for one, and the documents, events and notices found wrong stay as they were.
Nothing is ever erased: every filing, every day's checks, every status and every withdrawal stay in the public history.
The notices
Each status change of a filed agent is a status_changed notice under agent:<id>, and each rule of a Chartered agent that begins to fail is a rule_failing notice. They are text from fixed templates, as every notice is (rules.notices), and name the statuses as the roll records them. The two notices of a linked token's creator fee recipient, under token:<address>, are below them.
status_changed
- Source: the status machine, on an accepted filing, a withdrawal, a transfer seen by
register.crawl, a day's checks, or a correction. - Payload:
agentId,from,to,reason,rule,byStatement,rulebookVersion,documentHash; for a correction alsocorrects, the status document found wrong, andmethodVersion, the version of this method that reran it. - Time: when the change was made.
- Evidence: the status document, by its SHA-256.
Agent <id>: status changed from Unchartered to Provisional at <time>, under rulebook version <version>. A filing was accepted.
Agent <id>: status changed from Provisional to Chartered at <time>, under rulebook version <version>. Every rule passed, after the history the rulebook asks for.
Agent <id>: status changed from Chartered to Revoked at <time>, under rulebook version <version>. Rule <rule> still failed when its grace period ended.
Agent <id>: status changed from Chartered to Revoked at <time>, under rulebook version <version>. A check of rule <rule> showed a statement of the filing to be false.
Agent <id>: status changed from Revoked to Provisional at <time>, under rulebook version <version>. A new filing was made, and rule <rule> passes again.
Agent <id>: status changed from <old status> to Unchartered at <time>, under rulebook version <version>. The owner withdrew the filing. Unchartered means the agent has not filed. The term carries no judgement.
Agent <id>: status changed from <old status> to Unchartered at <time>, under rulebook version <version>. The identity was transferred, which ends its filing. Unchartered means the agent has not filed. The term carries no judgement.
Agent <id>: status changed from <old> to <new> at <time>, under rulebook version <version>. The same evidence, rerun with rules.status <method version>, corrects the status document <hash>.
Agent <id>: status changed from <old> to Unchartered at <time>, under rulebook version <version>. The same evidence, rerun with rules.status <method version>, corrects the status document <hash>. Unchartered means the agent has not filed. The term carries no judgement.
notice_corrected, beside a status document found wrong
- Source: a correction, beside the
status_changednotice of the first status document found wrong, as every wrong notice gets one (rules.notices). - Payload:
noticeId, that notice, andreason, the sentence after its first. - Time: when the correction was written.
- Evidence: the corrected status document, by its SHA-256.
Correction to notice <number>. The status was computed with a fault fixed in rules.status <version>: <fault>. The same evidence gives <status>.
rule_failing
- Source: the day's checks of a
Charteredagent. - Payload:
agentId,rule,since,graceEndsAt,clockStopDays,rulebookVersion. - Time: the evaluation that found the rule failing.
- Evidence: the failing check's reads.
Agent <id>: rule <rule> failed at the evaluation of <time>, while the status is Chartered. The status changes to Revoked if the rule still fails on or after <deadline> without having passed <days> days in a row.
fee_recipient_changed
- Source: the job
master.pons-watch, which reads the launch record (getLaunchedToken) of the tokens the filings in force link, the tokens of a few agents each hour and the next agents' the hour after, until every linked token has been read and it starts again; and compares each token's creator fee recipient with the last confirmed read. - Fires when: the recipient differs, and a second read at the same block, from an endpoint run by another operator, shows the same new recipient. A token's first read is kept only once the second endpoint shows the same at the same block, so the old recipient of a change is never one endpoint's word.
- Payload:
token,from,to. - Time: first observed.
sinceis the last read known to have returned the old recipient, as a block. - Evidence: the
getLaunchedTokencall that returned the old recipient and the one that returned the new one, each with its block. - Read twice: yes.
R7 reads it for the tokens the filing links: an amendment must follow within 7 days.
Token <address>: creator fee recipient changed from <old recipient> to <new recipient> between <since> and <time>. Seen by comparing two reads.
takeover_pending
- Source: the same job, from
pendingCreatorFeeRecipient, which names a proposed recipient, when the change can take effect and when the proposal lapses. - Fires when: a proposal is pending that the last confirmed read did not show, and a second read at the same block, from another operator's endpoint, shows the same proposal.
- Payload:
token,current,proposed,effectiveAt,expiresAt. - Time: first observed.
- Evidence: the
pendingCreatorFeeRecipientcall that showed it, with its block. - Read twice: yes.
Token <address>: a change of its creator fee recipient from <current recipient> to <proposed recipient> was proposed, effective <effective time> and lapsing <lapse time>. First observed at <time>.
pledge_broken
- Source: the weekly check of a filed pledge (
charter.pledges), below. - Fires when: a check finds the pledge Broken, the first time.
- Payload:
agentId,pledgeHash,template. - Time: the check that found it.
- Evidence: the reads that check rests on.
- Read twice: no. A wrong one is corrected like any other notice.
Agent <id>: a <template> pledge, <pledge hash>, was found Broken at the check of <time>. A Broken check counts against the rule on pledges for the days the rulebook states.
opinion_changed
- Source: the ingest of a new
Auditreport, where the newest report of the agent before it gives another opinion. - Fires when: the new report covers the agent up to a day at least as late as the newest before it, and its opinion differs.
- Payload:
agentId,from,to,reportHash. - Time: when the new report was recorded.
- Evidence: both reports, by their SHA-256.
- Read twice: no. A report is never replaced: a wrong one is corrected by its next revision.
Agent <id>: the opinion of its newest audit changed from <old opinion> to <new opinion>. Report <report hash>. First observed at <time>.
Pledges
A pledge is a promise in one of seven fixed forms. The identity's owner files it, or, for a pledge about a token the agent's filing in force links, that token's creator fee recipient, by signing it as EIP-712 typed data (CharterPledge: the agent, the registry, the template, its parameters as canonical JSON, a nonce and an expiry), and only an agent with a filing in force can pledge. A token's recipient speaks for the agent about no other token, so nobody can plant a pledge on an agent through a token of their own. An identity may have 3 pledges accepted in one UTC day, and 20 in force at once. When it is accepted, the server reads what the template compares with later: the holder's balance (NO_SELL), the burn address's balance and the total supply (BURN), the creator fee recipient (FEE_RECIPIENT_FIXED). Code checks each pledge once a week, and once more after it has run its course, each pledge's reads in a request of their own: a token whose answer reverts or cannot be read makes only its own pledge's check Unverifiable that week:
| Template | Kept | Broken | Pending | Unverifiable |
|---|---|---|---|---|
LOCK_UNTIL | The holder held at least the amount at the check | It held less, before the date | Its balance could not be read | |
NO_SELL | The holder's balance is not under the one it started from | It is under it, before the date | Its balance could not be read, now or at the start | |
BURN | At least the amount went to the burn address or out of the total supply since the pledge | Less had, by the date | Less has so far, before the date | Either value could not be read |
FEE_RECIPIENT_FIXED | The recipient is the one it was | It changed, or a fee_recipient_changed notice shows a change, before the date | The launch record could not be read | |
SERVICE_LIVE | The endpoint answered at least the share of its daily probes of the week | It answered fewer | Fewer than 5 probes in the week | It cannot be asked |
BUYBACK, FEE_SHARE | Always, in this version: FACTA does not read the creator fees a token's recipient claims yet |
A pledge of one deadline that one check found Broken stays Broken: a later balance does not mend an earlier one. SERVICE_LIVE is judged week by week. A balance is read at the check, once a week: a holding that dips and recovers between two checks is not seen. Any burn counts toward a BURN pledge, whoever sent it.
The entry on the chain
Each status change of a filed agent is written once a day, from the batch lane, as one entry in the ERC-8004 Reputation Registry (
0x8004baa17c55a88189ae136b182e5fda19de9b63), from FACTA's attester address, which is published on the site, holds only gas money, and owns and operates no agent. The registry refuses an entry from an agent's own owner or operator.The entry is
giveFeedback(agentId, value, 0, "charter.status", "rulebook-v<version>:<owner>", "", feedbackURI, feedbackHash), with the value1forProvisional,2forCharteredand3forRevoked,feedbackURIthe status document's URL andfeedbackHashthe Keccak-256 of its bytes. The agent's previous entry is revoked first. Nothing is written forUnchartered: a withdrawal or a transfer revokes the last entry instead.<owner>is the identity's owner who signed the filing in force, as0xand 40 lower-case hex digits, the form OpenZeppelin'sStrings.toHexString(address)writes. A contract that reads an entry checks three things: it was written by FACTA's published attester; its second tag equals"rulebook-v1:"followed by the registry'sownerOf(agentId)now; and it is the only entry of that attester in force. An entry written before a transfer then fails the second check at once, before FACTA has revoked it, which the next run does.A correction is written the same way: the corrected status document is the agent's newest, so the entry in force, the wrong one, is revoked and the corrected entry written. A correction to
Uncharteredonly revokes.The entry is a copy. The status document on FACTA's site is the record: one outside address can upgrade the registry, so if the registry changes in a way that breaks this, FACTA stops writing there and says so.
The registries are watched. Once a UTC day, FACTA reads the Reputation Registry's and the Identity Registry's code and owner at the head, on two endpoints run by different operators. The code is the EIP-1967 implementation slot, and the owner is
owner(). Each read is kept, andGET /v1/shows them. The code and the owner the lead read are:charter/ registries - Reputation Registry: implementation
0x16e0fa7f7c56b9a767e34b192b51f921be31da34, installed at block 30,811,800 on 2026-08-08; - Identity Registry: implementation
0x7274e874ca62410a93bd8bf61c69d8045e399c02, installed at block 30,786,111 on 2026-08-08; - the owner of both:
0x547289319c3e6aedb179c0b8e8af0b5acd062603.
The attester writes only while each registry was read on that day or the day before, as listed. New code, a new owner, a value two endpoints do not show alike, or a day with no read holds it. Nothing is then written until the lead has read the new code and a new version names it here. The batch lane reads both registries again itself just before it sends.
- Reputation Registry: implementation
The key that signs the entries never lives on FACTA's server.
Reading the entry from a contract
Filter by FACTA's attester address and by the first tag every time. The registry lets anyone write any tag, and stores no time with an entry, so neither filter is optional. The attester address is published on this page and on the developers page once it exists. Until then, no entry is written.
The fast way takes three reads, whatever the agent's history: the attester's last entry for the agent, then the identity's owner now.
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
interface IReputationRegistry {
function getLastIndex(uint256 agentId, address clientAddress) external view returns (uint64);
function readFeedback(uint256 agentId, address clientAddress, uint64 feedbackIndex)
external view returns (int128 value, uint8 valueDecimals, string memory tag1, string memory tag2, bool isRevoked);
}
interface IIdentityRegistry {
function ownerOf(uint256 agentId) external view returns (address);
}
library CharterStatus {
bytes32 private constant TAG = keccak256("charter.status");
/// 1 Provisional, 2 Chartered, 3 Revoked. 0 means no entry in force: the agent has not filed,
/// withdrew, changed hands, or its entry is not written yet. 0 carries no judgement.
function statusOf(IReputationRegistry reputation, IIdentityRegistry identity, address attester, uint256 agentId)
internal view returns (uint8)
{
uint64 last = reputation.getLastIndex(agentId, attester);
if (last == 0) return 0;
(int128 value, uint8 decimals, string memory tag1, string memory tag2, bool revoked) =
reputation.readFeedback(agentId, attester, last);
if (revoked || decimals != 0 || keccak256(bytes(tag1)) != TAG) return 0;
// An entry written before a transfer names the old owner: it fails here at once.
string memory owner = Strings.toHexString(identity.ownerOf(agentId));
if (keccak256(bytes(tag2)) != keccak256(bytes(string.concat("rulebook-v1:", owner)))) return 0;
if (value < 1 || value > 3) return 0;
return uint8(uint128(value));
}
}
The Reputation Registry is 0x8004baa17c55a88189ae136b182e5fda19de9b63, and the Identity Registry is 0x8004a169fb4a3325136eb29fa0ceb6d2e539a432, on chain 4663. ownerOf reverts for an identity that does not exist, so a caller that may pass one wraps the read.
Rules for every reader:
- Name FACTA's attester, and only it. A read with an empty list of clients, or with any other address, finds entries anyone could have written with the same tags.
- Read only the values 1, 2 and 3. Anything else is no entry.
- No entry carries no judgement, as
Uncharteredcarries none. - Fail closed. The attester revokes the agent's last entry before it writes the next. Between its two transactions the agent has no entry, and never two, so a change from
CharteredtoRevokedis never read asChartered.getSummaryaverages every entry it matches. A reader that uses it reads a count above 1, or decimals other than 0, as no entry. - An entry lags the site: by up to a day with the daily run, and longer while the batch lane is not running. The site and the API answer at once, from the database. A contract that needs today's answer reads the API off-chain.
- One outside address can upgrade the registry. A reader trusts that address as well as FACTA's.
- The attester address can change. A contract should let its own admin update the address it reads.
- The second tag names the rulebook version and the owner. A reader that accepts a later version compares the part after the colon only.
Thresholds
| Threshold | Version 1 |
|---|---|
History before Chartered | 30 days |
Grace period of a failing rule of a Chartered agent | 14 days |
Passing days in a row that stop the grace clock | 7 |
R4: daily probes a service needs in 30 days before its share counts | 27 |
R4: share of daily probes answered | 90% |
R5: oldest audit | 90 days |
R6: how long a Broken check counts | 90 days |
R7: days for an amendment | 7 |
Notice of a new rulebook version before it applies | 14 days |
Days are whole UTC days.
Terms
Unchartered,Provisional,Chartered,Revoked: the four statuses, as the vocabulary defines them. Unchartered means the agent has not filed. The term carries no judgement.Pass,Fail,Pending: the outcome of one rule's check.
Evidence
Each check cites what it rests on: the registry calls with their blocks, the registration file by its hash, the filing and the audit report by their SHA-256, each daily probe with its time and outcome, and the notices of the changes R7 watches. Each status change has a status document, served at /v1/, holding the rulebook version, the reason, the rule a revocation names, and the day's seven checks it rests on.
Recomputation
Take the rulebook version and the checks of a status document, and apply the machine above from the agent's first filing: the same status follows. Each check can be recomputed from the reads it cites. A correction's document names the state its rerun started from and each event it reran, every evaluation by the SHA-256 of the input or the checks it was rerun over, served at /v1/: rerun them from that state with the code of the version the document names, and the same status follows (packages/rules/recompute.ts). A filing's signatures can be checked by anyone: the EIP-712 domain is FACTA, version 1, chain 4663.
Known ways to game this method, and what it does about each
- Buying a status, or paying for a better one. There is no path from any payment, key, balance or vote to a status: the machine's only events are a filing, a withdrawal, a transfer and a day's checks, a correction reruns those same events, and the code that computes them reads no payment.
- Declaring a wallet that belongs to someone else. Every declared wallet signs the filing.
- Hiding the wallet that really receives payment. The wallets the agent's own payment terms name must be declared (R3), and a filing signed while the terms named an undeclared wallet is a statement shown false.
- Keeping a service up only when it is probed. Probes run daily at times that are not announced, and the threshold is 27 answered days in 30.
- Fixing a failing rule for one day in every 14. The grace clock stops only after 7 passing days in a row.
- Withdrawing, or moving the identity, just before a revocation. The history shows the failing rule at the moment of the withdrawal or transfer, and any new filing starts again at
Provisional. - Buying an identity that is
Chartered. A transfer ends the filing, so a status never passes with an identity. - A forged or replayed filing. The signed data names the chain, the registry, the agent, the whole filing, its place in the sequence, the entry before it, a number used once and an expiry. An entry is accepted once, in its place, and the owner is checked again at every evaluation.
- A false contact. The contact is published as given. Code checks only that it is present and well formed.
- Asking for a correction to get a better status. A correction is a recomputation: only an upload signed from FACTA's batch lane starts one, under a version that fixed a fault of FACTA's code, and it names an agent and a status document and nothing else. No request has a field for a status, a rule or an outcome, and no public route starts one.
Limits
- Code cannot see a wallet the agent never uses in public: R3 checks the agent wallet and the wallets the agent's own payment terms name.
- The registry entry can only be as reliable as the registry, which one outside address can upgrade.
- R7 watches the agent wallet and the creator fee recipient of each linked token launched on Pons V2. A recipient that changes and changes back between two reads of its token leaves no notice; with many linked tokens, a token is read every few hours rather than every hour.
- A correction reruns only what was stored. An evaluation made before version 0.2.0 kept its checks but not its input, so only a fault of the machine can be rerun over it; a day whose input cannot be rebuilt to the SHA-256 it kept is not corrected, and the run says which. One correction reruns at most 300 events.
- R6 reads the pledge checks of the last 90 days. A pledge not checked yet is no Broken pledge, and R6 says only what the checks it read found, never that no pledge is on file.
What overlaps elsewhere
- The ERC-8004 Reputation Registry already holds scores that other services post about agents. FACTA's entry is one more, tagged
charter.status, and it says only which rules the evidence shows passing. - What this method adds is a status that anyone can rebuild from public evidence and a published rulebook, under rules that are the same for every agent.