register.liveness
- Version
- 0.1.0
- Desk
- Terms named on this page
Gives each identity one term of the liveness vocabulary: what was observed when its registration file and the services it declares were asked.
Changelog
| Version | Date | Change |
|---|---|---|
0.1.0 | 2026-11-11 | First version. |
What it measures
Whether an identity has a registration file, whether that file can be read, and whether the services it declares answer, and how.
It does not measure whether a service is useful, honest or fast, whether it is run by the identity's owner, or anything about money. A Live service answered once, as its protocol requires; nothing more.
Terms
| Term | Observed | Set by |
|---|---|---|
No card | The identity has no registration URI | register.crawl |
Unreachable | It has a URI, and the file could not be read under the fetch rules in three attempts, or what came back is not a registration file | register.file-fetch |
Card only | The file is valid, and it declares no service that could be asked, or none of those asked answered at all | register.file-fetch when the file declares none; otherwise register.liveness |
Site only | The file is valid, at least one declared endpoint answered over HTTP, and none answered as the service it claims to be | register.liveness |
Live service | The file is valid, and at least one declared endpoint answered correctly: an MCP handshake, an agent card that parses, or a payment-required response with valid terms | register.liveness |
The job that learns a term sets it. Until then there is none. An identity whose file has not been read shows that register.file-fetch is pending; one whose valid file declares services that have not been probed shows that register.liveness is pending. The home page counts identities with no term under "No term yet", so the counts always add up to the number of identities.
How a service is asked
- Only services with an
httpsendpoint can be asked. At most four are probed per identity, with at most two requests each: MCP, agent-card and payment endpoints first, then the others in the file's order. - Every redirect a request follows is a request too, and the probes of one identity send at most ten requests in all. Each request is told how many its identity has left: a redirect it cannot follow within them ends it with too many redirects, and a service its identity has none left for is recorded as not requested, with the detail
Not requested: one identity's probes send at most 10 requests, redirects included. - A service is MCP when its declared name is
MCP. It is an agent card when its name isA2A,agentcard,agent-cardoragent card, or when its endpoint ends in/.well-known/oragent-card.json /.well-known/. It is a payment endpoint when its name isagent.json x402,paymentorpayments. Names are compared without case and without the spaces around them. Any other name is asked as "any other service" below. - MCP, both generations: first the 2026-07-28 revision's
server/discover(a POST with the headersMCP-Protocol-Version: 2026-07-28andMcp-Method: server/discover), then, when that does not answer as MCP, the 2025initializehandshake. Either answer counts: aserver/discoverresult withsupportedVersionsandcapabilities, the revision's unsupported-version error that lists the versions the server supports, or aninitializeresult with aprotocolVersionandcapabilities. A JSON answer and an event stream are both read. The crawler does not close a 2025 session it opened. - Agent card: a GET of the endpoint, and when the endpoint is not itself a JSON file, a GET of
/.well-known/on the same host. A card parses when it is a JSON object with a name, a way to reach the agent (agent-card.json supportedInterfacesorurl) and itsskillsorcapabilities. - Payment: one GET. Valid payment terms are a 402 whose terms, in the base64
PAYMENT-REQUIREDheader (x402 version 2) or in the JSON body (version 1), name at least one way to pay with a scheme, a network, an asset, an amount and a recipient, all well formed. Any 402 without them answered over HTTP and no more, and so did a 405 to the GET. - Any other service: one GET. A 402 with valid terms on any probe counts as an answer as the service.
- A body goes only to an endpoint declared as MCP: the two fixed handshakes above, because a body is that protocol. Every other service is asked with GET only. A request with a body to an address a stranger chose could act under FACTA's name.
What is parsed of an answer. An answer is counted before it is parsed, by the same scan as a registration file (the counts, the limits and what they cost are on the register.file page):
- An answer nested more than 64 levels deep, or holding more than 4,000 parts (opening brackets, commas and colons outside strings), is not parsed: it cannot answer as the service, and it counts by its status.
- A step parses at most 300,000 bytes and 8,000 parts in all the answers it gets, whatever one identity declares. Four services asked twice can return eight answers of 256 KB; without this the step would parse 2 MB.
- An answer that does not fit what is left of the step is not parsed. What follows depends on who used the step's budget. When other identities did, this identity is left for the next step, which starts with it: nothing is written, and no identity's term depends on what another identity's answers used. When the identity had the whole step to itself and its own answers passed the budget, the answer counts by its status, its detail reads
HTTP 200, answer not parsed: over the step's parse limit, and the sweep moves on. - An event stream is counted whole, by its length, before anything is read from it, under the same rule. Then the first 16 of its events that hold data are found, line by line, and each event's data is parsed with its structure counted. The body is never split whole: 256 KB of blank lines, or of lines with no data, costs a scan and counts as 256 KB.
- A body is parsed once, whatever is asked of it.
Answered over HTTP means a response with a status from 200 to 399, or 401, 402, 403 or 405. A 404, a 410 and every 5xx are no answer: a hosting platform answers those for an app that is gone. A response the fetch rules cut off while it was arriving (too large, wrong content type) counts by its status. A status line whose body then stalled or was dropped is not a response: it is a failed attempt, as the next section says.
A probe's detail is built from a fixed template and a status code, for example MCP server/discover answered, HTTP 404 or HTTP 200, then no full answer: timeout. It never holds text from a response.
A term never gets worse on one failed attempt
A 429, a 5xx, a timeout or a network error is not yet a result. When such failures could have changed the outcome, the identity keeps the term it had, its attempt count goes up, and it is asked again six hours later. Only the third check in a row lowers the term. A definitive answer, such as a 404, lowers it at once.
- A timeout or a network error is a failed attempt whether it came before the response headers or after them. An endpoint that sends HTTP 200 and then stalls the body past five seconds, or drops the connection in the middle of it, did not answer over HTTP and did not answer as the service, whatever the status was. Its detail reads
HTTP 200, then no full answer: timeout(ornetwork error). - A failed request counts against the whole service. A service is asked with up to two requests. When any of them failed for a passing reason and the service did not answer as itself, a full answer could have bettered the outcome, so the term is not lowered on it. Example: a 2025 MCP server answers the 2026-07-28 discovery with a plain error, in full, and the answer to its
initializehandshake is dropped. On that check the identity keepsLive service; three such checks in a row make itSite only. - A first classification waits the same way. With a passing failure among its requests it sets no term until the third check in a row, unless a service answered as itself:
Live serviceis set at once.
What an answer says meanwhile. While the last check failed for a passing reason, the answer names liveness under stale. With a term, it says the term shown comes from an earlier check and gives that check's time: the time of the probes the term rests on. With no term yet, it says so, and gives no time as a check that succeeded. Either way it says when the services are due to be checked again: six hours after the failed check. A term not checked for more than 21 days is named too, with the time of its check, and the answer says no time can be given for the next one.
A term is written only for the file whose services were asked
A check reads an identity's file from its row, asks the services that file declares, and writes the term. The write applies only while the row still holds that file and has not been written by any job since the check read it. If the file sweep stored another file meanwhile, or the full read found the registration URI changed, the result is dropped: no term is ever set from the services of a file that is no longer on record. The identity is classified again from the file then on record, or needs no probe when that file declares no service.
A term is set only from the services of a file the chain still names. The full read records a change of the registration URI up to one of its windows after the change. Until then the file on record is one the agent has left, and its services are not the agent's to be asked. So, before it asks any service, a step reads tokenURI of the identities it may check, at the head of the chain, in one request, as the file sweep does. An identity whose URI the chain no longer names is not probed, and no term is set or lowered from its file: it stays due until the full read records the new URI, which clears the term and the file. It does not hold the sweep: the step goes on past it, and the next pass meets it again. That read is made as the file sweep makes it (see register.file): an answer over the size cap cuts the identities into parts of at most eight, and a part of eight or fewer that is still over it holds a URI the chain has moved to one longer than any a row holds. The identities of such a part that the step could not tell apart are passed in the same way: not probed, still due, and met again by the next pass.
A changed file keeps the term only for the same services. When the file sweep reads a file that differs from the one on record, the term, its time and its failed checks stand only when the probes the term rests on are exactly the probes the new file gets: the same services, by name and endpoint, in the order they are asked. A file that changed only its words keeps them. Otherwise the term is cleared with its failed checks, and register.liveness is pending: no term is shown for services nobody has asked, and the old services' failures never count against the new ones.
Thresholds
| Threshold | Value |
|---|---|
Services probed per identity | 4 |
Requests per service | 2 |
Requests for one identity's probes | 10, every redirect included |
Requests a step | 30, at most 10 to one host |
Parsed a step | At most 300,000 bytes and 8,000 parts, counted before each answer is parsed |
Structure of one answer before parsing | At most 64 levels of nesting and 4,000 parts (opening brackets, commas and colons outside strings) |
Checks before passing failures lower a term | 3, six hours apart |
A step's page | The due identities among the next 500 IDs past the cursor, at most 24 of them. Reading the page reads at most 502 rows, whatever the rows hold, and each write one more |
Sweep window | 7 days. A pass reads the table page by page and is followed by a wait of six hours. The run ends with the first pass that ends after its window, and then stores the counts by term |
Stale | 21 days without a check |
Evidence
| Figure | Value | Evidence |
|---|---|---|
liveness | The term | Each probe that returned a body: the URL it was fetched from, when it was asked, and the SHA-256 of what came back. A card found at /.well-known/ is cited as a fetch of that URL, never of the declared endpoint. For No card, the tokenURI(uint256) read that showed no URI. When no request returned a body, the URI read. The figure's time is the time of those probes: never the identity's chain read, and never a later check that failed. Its window is the block of the URI read when its evidence is that read, and none when it cites only fetches |
The probe results themselves are part of the answer: service, endpoint, outcome and the fixed detail. When the term rests on FACTA's own read of the registration file (Unreachable, or Card only for a file that declares no service that can be asked), that read is among them, marked kind: 'file': it is FACTA's read, never a service the subject declared, and its evidence is the fetch of the file.
Recomputation
A term rests on answers that change with time, so the recomputation script marks it not re-read. To ask an identity's services again, by the same functions the sweep runs:
pnpm tool packages/register/classify.ts <agentId>
It prints the term with every probe result. It is a fresh classification: a passing failure is reported as such.
Known ways to game it, and what the method does
| Way | What the method does |
|---|---|
The cheapest: the operator writes its own name and description, flattering, or worded like a term or like FACTA | They are the subject's own words. Every surface shows them as a quotation under "Declared by the subject, not checked", after the terms and never in their place or style. The term is computed from probes only; no word of the file is ever read as a term |
A server that returns a well-formed MCP answer, card or 402 to anyone | It is Live service: the method checks the protocol's form, not the service behind it. Stated here |
Declaring someone else's popular site as a service | That site answers, so the term is Site only. The term says an endpoint answered; it does not say who runs it |
Declaring someone else's MCP server, agent card or payment endpoint as a service | That endpoint answers as its protocol requires, so the term is Live service. The term checks the protocol's answer; it does not say who runs the endpoint, or that the identity's owner does |
A service that fails now and then, to keep Live service | It keeps the term through two failed checks; the third lowers it |
Sending the status line of a good answer and never its body, to count as answering | A status line without its body is a failed attempt: not an answer over HTTP, and never an answer as the service. The third such check in a row lowers the term |
Text in a response written to look like a FACTA line | A detail is a fixed template and a status code; no response text is kept |
Answering FACTA's crawler differently from others | The crawler says what it is. The method records what it was served |
Many identities on one host | Ten requests to one host a minute: that host's identities are checked more slowly; nobody else's are |
Endpoints that redirect to themselves, so that one identity's probes need more than ten requests to one host and the sweep stops before it in every step | Every redirect counts against the identity's ten requests. Its probes end where those run out, the services left are recorded as not requested, the identity gets its term, and the sweep moves on. In a test, four such MCP endpoints on one host took ten requests, and the next step probed an identity 599 IDs further on; before this rule every step stopped before the redirecting identity |
Four services that each answer both requests with 256 KB, to make one step parse 2 MB and be cut off, so the sweep never passes this identity | Every answer is counted before it is parsed, and a step parses at most 300,000 bytes and 8,000 parts. The answers that no longer fit count by their status, the identity gets its term, and the sweep moves on |
The same with event streams of blank lines, or of lines with no data field, which held no data to count | An event stream is counted whole, by its length, before its events are read, and it is never split whole. On four such identities a step stops after nine requests, where it sent 24 |
Moving the registration URI to a file with other services, while the old file's services still answer, or no longer do | The URI on chain is read before any service is asked. The services of a file the chain no longer names are not asked, and no term is set or lowered from them |
Moving many URIs to tens of kilobytes on chain before the full read sees it, so that every read of the URIs is over the size cap and the sweep stops at them | A part of eight identities or fewer whose URIs are still over the cap holds a moved URI: those identities are passed, not probed, and the sweep goes on. In a test on 25,000 identities, read through the same reader as the Worker's, sixteen URIs moved to 40,000 bytes cost a day of 150 steps and 75,346 rows read, and every other due identity was checked that day. Before this rule the same day took 300 steps at them and checked no identity after them, until the full read recorded the long URIs. What it still costs is under Limits |
A file that keeps the services that earned Live service in name only, then moves them to an endpoint that never answers | A changed file keeps the term only when its probes are exactly the ones that earned it. A new endpoint is asked before any term is shown for it |
Large answers from an identity registered just before another, so that the other's answers no longer fit the step and it is judged on its status alone | An identity whose answer does not fit what others left is not judged in that step. It is left for the next, which starts with it and gives it the whole budget |
Declaring a webhook or a form as a service, so that the crawler sends it a request that acts | Only an endpoint declared as MCP is sent a body, and only the two fixed handshakes. Every other service gets a GET |
Limits
- Only four services per identity are probed. A file that declares more is judged on the four chosen by the order above.
- An MCP server that requires sign-in before discovery answers 401: it is
Site only, because no handshake was observed. - A payment endpoint that takes only POST is not seen to answer as a payment endpoint: the crawler sends it no body, so it sees no payment terms. A 405 to the GET is
Site only; a 404 is no answer. - An answer of more than 4,000 parts is not parsed, also when it is a well-formed agent card with very many skills: it then counts by its status. The same holds for the later answers of one identity whose answers together pass 300,000 bytes or 8,000 parts.
- An identity that is left for the next step because its answer did not fit is asked again there: its endpoints get the same requests twice in that sweep.
- A check runs about weekly; a service that comes back between two checks is seen at the next.
- When the registration URI changes on chain, the services of the new file are asked only once the full read has recorded the change and the file sweep has read the new file. Until then the identity keeps the term its old file earned, with that check's time.
- Each step that checks identities makes two more requests first: the head of the chain, and the read of their URIs at it.
- What a long new URI costs. A URI the chain moved to one longer than any a row holds is not known as such until the full read records it, up to one window of the full read later. Until then, each step that reaches its identity reads the URIs again in parts, up to five requests where it makes two. And the identities read with it in a part of eight or fewer that is over the size cap are passed with it: up to seven others wait for the next pass, and wait again at each pass while the long URIs stay unrecorded. No term is set or lowered for them meanwhile: each keeps its term and the time of the check it rests on.
What exists elsewhere
Counting which agents are alive is not new. Toll's agent census (https://t0ll.xyz/agents/census) probes every identity: whether its card loads, whether its MCP or x402 endpoint answers, and whether the recipient its x402 terms name equals its agent wallet. On 2026-11-10 it counted 22,843 registered, 11,070 broken cards, 6,622 x402 sellers and 1,105 agents answering over MCP. A provider-run ERC-8004 explorer lists 22,843 agents with their feedback and validation events, and 8004scan (https://8004scan.io) indexed 22,547 agents and publishes counts of MCP and A2A agents.
FACTA's totals differ from theirs for stated reasons:
- When each read was made. New identities arrive at about 50 an hour (measured on 2026-11-10), so two counts a few hours apart differ by hundreds.
- What counts as broken. Here a file is
Unreachableonly after three passing failures in a row or a definitive result, and a JSON file without the ERC-8004 registration type isUnreachable. - What counts as a payment endpoint. Here a 402 counts only with valid terms in the answer. A file that sets
x402Supportdeclares; it is not counted. - What counts as MCP. Here both generations of the protocol count, and at most four services per identity are asked.
What FACTA adds is not the count: it is the link from each identity to its money (register.links), with the evidence behind every figure.