# How a Teppi grade is produced

Version 31, written 2026-10-02 (UTC). What changed, and when, is at the end.

Every number here comes from a payment that settled and a response that was kept. Nothing on this
page has to be taken on anyone's word: the last section is how to recompute any of it yourself.

This is not a check of whether an endpoint speaks its protocol correctly, declares the right
schemas, or annotates its tools the way a spec asks. Those are worth knowing and other projects
already publish them from a free handshake alone. Every number on this page required a settled
payment: it answers whether paying got you what the listing said it would, which a handshake
cannot tell you and a schema cannot promise.

A credential that costs nothing to fake stops telling a buyer anything once faking it is cheap,
and generative output made most portfolios and sample answers cheap to produce. Bauer,
arXiv:2607.26327, shows the signal that survives is the one priced on the outcome rather than the
artifact: a warranty paid out on failure, not a fee paid for production. A settled payment and a
checked response is priced the same way.

## What is measured, and what is not

Teppi pays for a capability at its listed price and records what came back. It does not ask
sellers anything, does not accept submitted results, and has no form through which a rating can
be entered.

Three tiers, and they are never mixed into one ranking:

| Tier              | Evidence behind it                                                            | correctness | honesty  |
|-------------------|-------------------------------------------------------------------------------|-------------|----------|
| LIVENESS_VERIFIED | A free handshake. Nothing was bought.                                         | null        | null     |
| DELIVERY_VERIFIED | Paid. The seller published no output schema, so only delivery can be checked. | null        | measured |
| OUTCOME_VERIFIED  | Paid, and the output was checked against what the seller published.           | measured    | measured |

On the free tier, correctness and honesty are the literal value null. They are never zero and
never imputed, because a handshake says an endpoint answered and nothing about what it answered
with. A composite computed over four components is not comparable to one computed over six, so
the tier appears beside every band, everywhere.

## One probe

A probe is one unpaid request followed by one paid request to the same endpoint.

1. The unpaid request. Teppi reads the 402 and the payment terms out of it.
2. The cheapest rail that can actually be paid is chosen, which is often not the one listed first.
3. A receipt is opened before any money moves, keyed on a hash of the payment payload.
4. The paid request goes out.
5. The full transcript is stored, content addressed, before anything is judged.
6. The chain is asked what the transaction moved. A seller naming a transaction need not name an
   amount, so the amount comes from the chain and not from the seller.
7. Only then is the response scored.
8. Once a real payment has settled, the same signed authorization is sent once more. Nothing new
   is spent, since it was already consumed. A seller that verifies settlement refuses it; one that
   does not delivers again for nothing. The answer is recorded beside the response as
   `settlement_replay`: rejected, accepted, repeated, or unknown. Repeated means the second
   answer was 200 with exactly the bytes the payment had already bought: the seller handed its
   buyer back what was paid for and did no new work, which is not the failure accepted names.

That order is the guarantee. If the verifier dies at step 7, what the seller sent still exists.

A paid request that gets no answer within 30 seconds is not concluded on the spot, because the
authorization is already out and a seller can settle it after Teppi stops waiting. The transcript
records the question, the terms and the wait; the receipt stays open; and once the authorization
can no longer be settled, the chain is read for what moved from the paying wallet to the payee the
offer named. The record is then written, dated at the call: liveness 0, correctness unknown, and
honesty 0 if the money moved or 1 if it did not.

An answer that failed is held the same way whenever what it cost is unread, because a seller that
names no settlement, or names one no node can read yet, may still have taken the money. The answer
is judged when it arrives and the verdict is kept with the receipt; only honesty waits, and the
record is written with it once the chain has been read.

The wait lasts as long as the authorization does: at least 30 minutes, and until the moment the
seller's own terms let it be settled when that is later, plus five minutes for the transfer to land.
A chain that cannot be read leaves the receipt open rather than reading as nothing moved, and a
receipt open ninety minutes past that moment is a failed health check.

Probes are paid from a pool of wallets rotated so that no wallet pays the same payout address
twice within 14 days. A wallet rests 90 minutes between any two probes, and probing pauses rather
than reuse a wallet once fewer than 5 are eligible. The pool is not a secret and is not claimed to
be one: rotation limits what one seller can tell from the address that paid it, and nothing more.

A capability is drawn for probing 2.3 a day until 34 of its paid samples sit in the ninety day
window a letter is scored over, which takes about fifteen days, and twice a week after that. When
old samples leave the window and fewer than 34 remain, the rate goes back to 2.3 until the window
holds 34 again, since twice a week alone fills about 26 of the 30 a letter needs. Times come from a
Poisson process, so there is no timetable to serve differently. The pool is chosen among endpoints
somebody wants: the index saw ten calls in thirty days, a buyer bought one through Teppi, or an
agent asked about it. Teppi's own endpoints are paid for regardless, as coverage.

Outside that pool, each payout address somebody pays gets 1 paid call about every 18 days, on a
float of its own: the endpoint behind it that is paid for most, asked nothing held out, to see
whether it delivers what it charges for. 5 of those in 90 days never add up to a letter.
They are what shows an address that takes the money and answers nothing, which a free handshake
cannot see, and every one of them is a record like any other paid call.

Six paid calls in a row that deliver nothing stop the paying, and so does a record whose honesty
has settled below the lowest band, on the grounds that nothing further is learned by paying again.
Both of those wait for a letter when the seller is keeping the money: a run of misses that every
one of them settled goes on being paid for until a grade publishes a band, because there the free
handshake sees only a normal 402 and the paid call is the only record of what happened. Once the
letter is out, the paying stops.

The window is not the same for the two kinds of evidence. A handshake costs nothing and arrives
about twice a day, so a free card is scored over the last thirty days. A paid call costs money and, past
an endpoint's first month, arrives twice a week, so a paid card is scored over the last ninety.
Each card publishes the `window_days` it used and the `window_start` that follows from it, so
rescoring one needs no assumption about which.

A draw is not a probe. It becomes one only when a wallet is eligible under the rule above, and
sometimes none is, so the rate that settles runs below the rate that is drawn. Every scorecard
publishes the sample count behind it and the effective sample size behind each component, and
those are the numbers that say how much was actually checked.

## The six components

| Component          | Weight | What it is                                                |
|--------------------|--------|-----------------------------------------------------------|
| correctness        | 0.35   | Did the output match what the seller said it would return |
| honesty            | 0.25   | Was money taken for output that failed                    |
| schema_conformance | 0.15   | Did the response validate against the published schema    |
| liveness           | 0.15   | Did the endpoint answer at all                            |
| latency_p95        | 0.05   | The 95th percentile, against the median for its class     |
| price_stability    | 0.05   | Did the settled amount match the advertised one           |

honesty is the one buyers most need warning about. It is 1 when the output passed, 1 when the
output failed and nothing was charged, and drops toward 0 as more of the advertised price was
taken for output that failed. Refusing a request costs a seller nothing here. Charging for a
refusal is what it measures. A failure whose settlement nobody has read is not scored at all
until the chain has been read: unknown is not the same as nothing charged, and a refusal that
charged nothing earns its 1 only once that has been seen.

Whether the output failed is decided by the deepest check that scored the answer. When a held-out
check ran, it decides, and a response that agreed with every held-out field has not failed even
if it missed the schema it published: that miss is already the schema_conformance figure, and
counting it again here would charge one defect twice, once at 0.15 and again at 0.25. Only when
nothing deeper than the shape could be checked does the shape decide.

A held-out check compares the answer with a value written down before the draw. For a structured
answer it compares fields. For an answer written as prose, where no field holds the figure, it
reads every number the text states and passes when one lands within a declared tolerance, or finds
held-out words, case and spacing aside; a number is read whole, so 79 is not found inside 1979.
That second check is weaker, since an answer stating the figure among others still states it, and
it is used only where the answer is prose.

Some endpoints report a fact anyone can read for themselves: a balance at a block, a
transaction's receipt, the height of a chain, a spot price. For these a task need not hold an
answer back, and one written for such an endpoint is a question written at call time instead. The
probe draws a subject from recent activity (a transaction, or a program that received a token about
an hour before), reads the true value from two nodes run by different people at one block both
hold under the same hash, and only then pays and asks. After the answer comes back it reads the
same value again. The answer passes when it matches either read, or the value at the block the
answer says it read. When the answer names no block and matches neither read, the same value is
read at each block from a few past the second read, where the head was while both nodes caught up,
back to about two minutes behind the one pinned: the answer passes if it matches any of them, and is
wrong if every one held something else, since no block the seller could have read said what it
said. A pointer that finds nothing,
or nodes that disagree, leave the answer unknown, never wrong. A figure written with fewer places
than the chain holds passes within half its last place, the way rounding does. Where the answer is
prose rather than a field, it passes when the text states a figure within the allowed share of
the reads, which is weaker, since text stating the figure among others still states it.

A subject address always holds at least a kilobyte of code, so it is a program and never a
person's wallet: a smart wallet is a small proxy in front of shared code, and a delegated account
is 23 bytes. A balance of nothing is never asked, since it is right for almost any address. A price
is the median of at least three exchanges that need no key, and only when they sit within three
tenths of a percent of each other.

Nothing in such a question is held out, so the evidence publishes all of it: the subject, both
blocks and their hashes, every call each node answered and what it said, and how the answer was
compared. Anyone can send the same calls to an archive node of their own and reach the same
values. What this claims is that the seller could not have prepared for the question, since it
did not exist before the call. It does not claim the probe cannot be recognised.

On a handshake card, schema_conformance is the share of the schemas a seller declared that are
well formed. An output schema is optional, so a seller that declared inputs and no outputs is
scored on its inputs, and one that declared nothing has the component left out rather than
scored as a failure.

A remote mcp server is graded the same way from its own sweep, one observation per look the
sweep could see into. A look the server refused for want of a credential or a payment, or
throttled, is neither a pass nor a failure and produces no observation, so a server that answered
that way every time has no card rather than a card of zero. Its latency is measured against the
median handshake of every readable server in the window, its schema_conformance against what its
tools declared, and it carries TOOLS_CHANGED when the set of tool names it listed moved inside the
window. Nothing but a handshake has been bought from a server, so its card is LIVENESS_VERIFIED
and UNRATED however long it has answered.

latency_p95 is full marks at the median for its class and zero at twice it. A handshake card is
measured against the class's 402 round trips; a paid card against paid calls to the rest of its
class over the same window, since a delivery carries settlement and the work itself and a 402
carries neither. A class where nothing else was paid for falls back to paid calls across the
market. The card names the median it used as `class_median_latency_ms`, so the score can be
rerun from the card alone.

## Why the published number is a lower bound

Thirty perfect samples should not outrank three hundred. Every component is published as the
lower end of a 95% confidence interval, never as the average.

This bound is recomputed every time new evidence arrives, and a card is written by the rules under
When a card is written; a feed and a watcher read every card written. A fixed-sample interval such as Wilson promises 95% coverage
at one sample size chosen in advance; read at every size in turn, it breaks that promise. Simulated
over 200 looks at an endpoint whose true rate is 0.9, a Wilson lower bound rose above the truth in
11% of runs, and at a true rate of 0.7 in 16%.

Rates therefore use a time-uniform bound that holds at every sample size at once: the predictable
plug-in empirical-Bernstein confidence sequence of Waudby-Smith and Ramdas, arXiv:2010.09686. Under
the same simulation it stayed within its 5% promise. It is wider than Wilson at any given size, so
published numbers are lower and letters arrive later; that is the cost of a bound that is true
however often it is read.

Latency and price stability are not rates, one being a quantile and the other a deviation, so those
two use a bias-corrected bootstrap seeded from the capability id and the window, which makes the
figure reproducible rather than merely computed. That bootstrap is a fixed-sample method and
carries the same caveat.

Each component carries its own method name, its point estimate, its effective sample size, and
both ends of the interval where the method gives both. A lower bound alone cannot tell a reader
whether nothing is known or nothing works: after three failures the interval on a rate is still
the whole of zero to one, and only after fifteen does its upper end fall below the lowest band.
The bootstrap gives one end, so on those two metrics the upper end is left unsaid rather than
guessed at.

Rates are not trimmed. Trimming discards the extremes of a sample, and for a rate the extremes are
the failures: 99 successes and one failure, trimmed, reads as 100 successes. Latency and price
stability are still trimmed, where an outlier is an artefact rather than an observation.

Before any of that:

- Recent evidence counts for more, halving every 14 days.
- No single contributor may carry more than 10% of the weight behind a component. Anyone over
  that is scaled down.
- The top and bottom 5% are trimmed.
- A capability whose evidence is 25% or less diverse is flagged rather than quietly scored.

## How often a free look comes

Free looks go where they tell something. An endpoint an agent asked about, that a buyer bought
through Teppi, that the index saw called ten times in thirty days, that Teppi pays to probe, or
that Teppi sells, is looked at every 4 hours. Any other endpoint still offering terms is looked at
every 12 hours. One that stopped offering terms waits half as long as it has gone without them, at
least 12 hours and at most 7 days. A remote server behind a key or a price, which no look can see
into, is looked at every 3 days, and one that stopped answering backs off the same way. When the
sweep cannot reach everything in time the one due soonest goes first, so a larger market thins the
looks where they tell least.

## When a card is written

A card on a paid tier is written whenever its band, its composite or its sample count changes,
since one more paid call is a different claim.

A free card's lower bound tightens with every handshake as evidence builds up, which is not news
about the endpoint. A free card is written when its band or any flag changes, when its composite
falls by 0.020 or more from the last card written, when it rises by 0.050 or more, or once seven
days have passed and new handshakes arrived since. A fall is written sooner than a rise, since only
a fall can hurt a reader who relies on the card. Measured over the fortnight to 2026-09-26, this
writes about a quarter as many free cards as writing on every move of 0.010 or every day did.

An endpoint's cards are worked out again once something new has arrived for it: a paid call at
once, a handshake once 6 hours have passed since the last time, and at least once every 7 days
however quiet, since samples leave the window meanwhile. A remote server's are worked out again
once a look that can add an observation arrived and 12 hours have passed, and weekly the same.

Between cards, every answer about an endpoint says how many handshakes arrived after its newest
card, and its newest handshake is published beside the card, so a quiet card never hides a change.

## What stays in the database, and where the rest goes

Receipts, outcome records, corrections and every card on a paid tier stay in the database for
good. Handshakes and looks at remote servers stay six months, and free cards stay three months.
After that, each day of them is written to one file in the evidence store, read back and hashed
again, and only then removed. An endpoint's newest free card, a card a correction names, and a
handshake a seller's counter-probe cites never move.

Every file is listed at `GET /v1/archive` with the hash of what is inside it, in a manifest
signed the way a scorecard is and by the same key, and `GET /v1/archive/{id}/file` serves it:
one row a line, as the database held it, gzipped. Running `gunzip | shasum -a 256` on what you
fetch gives the hash its manifest names. A card asked for by its instant after it moved answers
410 and names the file it is in. Counts of handshakes and looks are kept as they arrive, so no
count falls when old rows move.

## Bands, and what UNRATED means

A composite of 0.90 or more is A, 0.80 is B, 0.65 is C, 0.45 is D, and anything below is F.

UNRATED is not a low grade.

A letter is only ever given to a tier somebody paid for. A free handshake tells you an endpoint
answered, which is not the same as it having delivered anything, so it stays UNRATED however long
it has been answering. Its components, its sample count and its composite are published in full;
what is withheld is the one-letter summary, because there is no delivery behind it to summarise.

Among the tiers somebody paid for, UNRATED means fewer than 30 samples, or a window
shorter than 14 days, or both. A capability with too little evidence is not scored, and it is
never shown as F. Unknown and bad are different facts and stay different everywhere.

Flags sit beside the band rather than replacing it, because a capability can be both genuinely
good and thinly evidenced at the same time.

## A buyer's own call, when the buyer publishes it

A buyer can buy one call through Teppi at `/v1/via/{id}` and be charged only if the answer came
back whole and matching the seller's published schema. If it sends `x-teppi-publish: transcript`,
the call enters the record beside the probes, with its transcript and evidence public like theirs.
A call kept sealed enters no record at all, since nobody but its two parties could rerun it.

Such a call is traffic a buyer wanted, paid for by that buyer. It counts toward liveness, the shape of the answer, honesty
and latency, and never toward correctness, since nobody holds a right answer to a buyer's own
request. Its source is one opaque name per buyer, `buyer:` and sixteen hex characters named in
its evidence blob, so one buyer is one contributor under the cap however many calls it publishes,
and its address is never published. A seller answering 4xx measured the buyer's request rather
than the seller, so that call carries no liveness and no shape, and still carries honesty: charging
for a refusal is the seller's either way. The same holds for a failed call whose request did not
meet the input schema the seller published, whatever status came back, and its evidence says so.

What such a call is not: a sample of what buyers nobody watches receive. Teppi pays the seller
from eight router wallets it reuses, from one host, so a seller that has been paid through Teppi
once can tell those calls apart, the same way it can tell Teppi's probes apart. A seller could
serve calls bought through Teppi well and other buyers worse, and these calls would not show it.
What that cannot do is lift a card, since a published call only ever lowers a component, or cost
the buyer who bought through Teppi, who pays only for an answer that passed. A buyer could also buy
calls meant to fail; five failed orders per buyer a day, one buyer as one source under the cap, and
the input schema rule above bound that, and a buyer is only an address.

A letter still needs 30 of Teppi's own paid probes over 14 days. A buyer's published calls add to
what is measured and never earn a letter on their own; a card counts them in its sample count,
and the evidence blob of each says which it was (`bought_for`). They can pull a component down
and never push it up: each component is worked out on every paid call and again on the probes
alone, and the card carries the lower of the two, since a seller buying its own endpoint through
Teppi gets its price back and each call it published would cost it only the fee.

## Reproducing any of it

Run the same probe yourself, from your own machine and your own wallet:

```
npx teppi-check <endpoint-url>
```

It needs nothing installed and sends the request the scheduled prober sends. A test runs both
against the same endpoint and fails if the bytes on the wire differ.

Every scorecard carries the settlement transaction, the hash of the request, the hash of the
response, the evidence hashes, the weights version, the bootstrap seed, and the id of the key it
was signed with. Fetch any of those hashes at `/v1/evidence/{hash}` and hash the bytes yourself:
the store is addressed by content, so the name is the proof. A hash from a probe that ran before
transcripts were kept answers 410 and says so, rather than answering as though it never existed. Fetch the key from `/.well-known/teppi-keys.json` and check the signature. The
canonicalisation is RFC 8785 and the algorithm is Ed25519, so a third party can reproduce the
signing input byte for byte.

If a scorecard names a key that document does not list, the signature cannot be checked and the
card should be treated as unverified.

A numeric field checked against a held-out value could not be reproduced this way, since
reproducing it needs the value that has to stay private. Where its golden task published a
commitment ahead of the draw, the evidence blob carries a zk proof instead: verify it against
the published commitment and you know the response landed within tolerance, without ever
learning what the tolerance was measured against.

## What Teppi does not do

- No seller can pay to change its grade, its rank, or whether it is routed to. A subscription
  buys coverage and never standing.
- No correctness or honesty number exists without a settled payment behind it. On a free
  handshake both are null, never zero and never inferred from anything.
- No grade of any tier comes from anyone telling us something. There is no review form and no
  endpoint that accepts a rating.
- Every record names the check that produced it, beside the transcript of what was said, so
  the number can be worked out again rather than accepted.
- No composite is published without its components, its tier and its sample count.
- No letter is published for a tier nobody paid for. The database refuses it.
- Nothing is settled above the advertised price. The database refuses it.

## What is wrong with a listing, before anyone pays

A grade needs paid samples and time. Whether a listing can be called at all needs neither, and a
buyer choosing between endpoints is owed it first. Every capability carries a list of defects,
each one a fact the reader can check from the listing and one unpaid call:

- `prose_in_the_url` - a query value spells out what to put there instead of putting it, so a
  call to the url as published measures the caller's request rather than the seller's delivery.
- `chain_not_offered` - the listing names a chain the endpoint did not offer when asked.
- `priced_but_answers_free` - listed at a price and answered 200 without asking for payment.
- `path_not_found` - the listed path answered 404 or 410.

Nothing our own request got wrong appears here. A 400 or a 422 means we sent the wrong shape and a
429 means we were asked to slow down, and none of those is a fact about the seller. Only the newest
answer counts, so an endpoint that was fixed stops being named.

An empty list means checked and clean. It never means unchecked: a listing nobody has probed
carries no defects and no claim.

## What the market gets wrong after money moves

Two things are only knowable once a real payment has settled, and both are published as counts
over the market at `GET /v1/market/findings`, never as a mark against the one capability that
happened to show them.

`settlement_replay_accepted` and `settlement_replay_sellers` count the capabilities and the
sellers that delivered again for an authorization already spent, from step 8 above. A repeated
answer is not counted: serving a bought answer back to the wallet that bought it is what an
idempotent seller does, and a reader can tell the two apart by comparing the bytes. Li, Wang and
Wang's "Five Attacks on x402" (arXiv 2605.11781, May 2026) describes the same failure from the
attacker's side as authorization replay and settlement verification bypass, and recommends that a
seller verify settlement before delivering. This record is where anyone can see how many do.

`paired_divergence` counts capabilities that answered a second wallet differently from the first
inside the same window, which is what serving one caller a different answer looks like from
outside.

`subcent_refused_sellers` counts sellers whose facilitator answered a paid call with
`subcent_quota_exceeded` inside the last thirty days: a price under a cent that the seller's own
payment path would not settle, which a buyer meets as a call it paid for and got nothing from.
The reason is the facilitator's word, kept on the receipt as it was given.

Three more counts describe the shape of the market's payment terms rather than a fault in them:
`x402_v2_terms`, `x402_terms_in_header` and `x402_metered_offers`, each counted off every
endpoint's newest 402 of the day. Two more read the escrow offers in those 402s:
`x402_escrow_offers` counts endpoints offering payment through an escrow that somebody has to
capture, and `x402_escrow_own_operator` counts those naming their own payee as the one who may
capture, which protects the seller and not the buyer. Three more read every token each newest 402
accepts, not only the cheapest one Teppi can pay: `stablecoin_ousd_offers` counts endpoints
accepting Open USD, `stablecoin_ousd_only` those accepting it and no token Teppi pays with (USDC on
Base, USDC.e on Tempo), and `stablecoin_ousd_only_wanted` those among them somebody wants, by the
rule the prober chooses what to pay for. Open USD on Base carries no signed transfer authorization,
so Teppi cannot pay or grade an endpoint that accepts only it, and that last count says how much of
the market falls outside the record for that reason. What all of these say in a given month is
written up at `/docs/reports`.

## Corrections, and a seller's answer

The record only gains rows. A grade is never edited and never deleted, and a correction is a new
entry that says so.

A correction names the entry it is about, says what went wrong, and is published beside that entry
rather than inside it, because the entry was signed before the correction existed. The entry stays
readable, and so does its signature. Reading a scorecard returns any corrections against it in a
`corrections` field.

Every fault a correction can name is one of ours. There is no value for a claim we still stand
behind and a seller disputes, so a correction cannot be used to withdraw an unwelcome measurement.

A grade computed after a correction is issued leaves out every record the correction names, and a
correction about the whole capability withdraws every record from before it was issued. A grade
computed before the correction stands as published, with the correction read beside it, so a
reader recomputing either one under its own clock gets the set it stood on.
There are five: `our_request`, meaning the entry measured something about the request we
sent rather than what the seller delivered; `not_the_sellers_endpoint`, meaning the entry was
attached to an address that seller never published; `our_expectation`, meaning what the
answer was scored against was ours and wrong, whether a held-out value or a schema the seller never
declared; and `our_record`, meaning the
transcript the entry cites was never kept, so the check it ran cannot be rerun by anyone and the
entry does not belong in a composite; and `our_verdict`, meaning every check the entry ran was
right and the figure drawn from them was ours and wrong, so the entry carries a number the current
verifier would not produce from the same transcript. Corrections cannot be edited or deleted either.

The whole log is at `GET /v1/corrections`, oldest first, and `GET /v1/corrections/summary`
adds it up: how many paid records have been published, how many a correction has since named, how
many held-out tasks have been scored against and how many were withdrawn. It is counted off the
same tables the log is read from, so anyone holding the log can check the sum. A benchmark that
never publishes its own error rate is asking to be believed about it, and this page does not.

A seller may answer any entry in the same format it was written, at
`POST /v1/counter-probe`, filing their own run and their own transcript. It is published beside
ours and labelled with whether they proved they hold the origin, which they do by publishing the
hash of their own evidence on it. It reaches no scoring path and moves no grade.

Teppi does not adjudicate between the two. A disagreement between two receipts belongs to whoever
is reading them.

## What changed on this page

### 31, written 2026-10-02

| Change | Reason |
|---|---|
| Versions are a plain count from here, one more than the entries before it, and every entry names the day it was written | The numbers before this counted changes within a month, so 2026.09.29 and 2026.09.30 were written on 2026-09-26 and 2026.10.1 on 2026-09-28, and each read as a day that had not come yet. They keep their names, since cards and pages already cite them |

### 2026.10.5, written 2026-10-01

| Change | Reason |
|---|---|
| An answer naming no block that matches neither read is checked at each block from a few past the second read back through the lag, also when both reads held the same value; verifier 2026.09.7 | Both reads sit a block or two behind the head so that both nodes hold them, and a seller reads the head itself. On 2026-09-30 an erc20 balance answered the value the chain held one block past our pin, both our reads held the value before it, and the answer was scored wrong. It is withdrawn under `our_verdict` |

### 2026.10.4, written 2026-10-01

| Change | Reason |
|---|---|
| `stablecoin_ousd_offers`, `stablecoin_ousd_only` and `stablecoin_ousd_only_wanted` join the market counts, read off every token a 402 accepts | Open USD went live on 2026-09-30 on Base, Ethereum, Solana and Tempo, and on Base it supports a permit but not a signed transfer authorization, which is how every Teppi payment is made. A handshake kept only the cheapest token Teppi could price, so an endpoint moving to it would have read as the token it left, or as nothing |

### 2026.10.3, written 2026-09-30

| Change | Reason |
|---|---|
| A held-out claim may name its place as a json pointer or as dotted keys, and a star in it stands for every item of a list, so a search answer passes when the page sits at any rank; verifier 2026.09.6 | Fifteen tasks written on 2026-09-27 named their place as a json pointer, which the verifier read as one key that never exists, so 26 paid answers on three endpoints read as correctness 0 and honesty 0 while every one held the text asked for. Rescored from their kept transcripts, all 26 pass; they are withdrawn under `our_verdict`. A search, unlike a lookup, puts the right page at no fixed rank |

### 2026.10.2, written 2026-09-28

| Change | Reason |
|---|---|
| A failed published call whose request did not meet the seller's own input schema carries no liveness and no shape; the page says what a published call is not | The router checked only that a body was json, so a buyer's malformed request answered with a 500 counted against the seller. And the page had said a seller could not tell a call bought through Teppi from its other traffic, which its eight reused wallets make untrue |

### 2026.10.1, written 2026-09-28

| Change | Reason |
|---|---|
| A task may be a question written at call time, for an endpoint that reports a fact anyone can read: the subject drawn from recent activity, the value read from two nodes at one pinned block before the call and again after it, or from three exchanges for a price; verifier 2026.09.5 | A held-out answer is needed only where nobody else can read the answer. For a balance, a receipt or a price, holding it back hid from strangers the one thing that lets them redo the check. On 2026-09-28 the endpoints reporting chain facts or market data under the probe ceiling that somebody uses numbered 348, and 16 of them had a task |
| `x402_escrow_offers` and `x402_escrow_own_operator` count the escrow offers in each endpoint's newest 402 of the day, and who they let capture | An escrow can hold a buyer's money until delivery only if someone other than the seller decides the capture, and nobody had counted which offers do |
| Each check names which kind it is, and a check from before that reads as one against a public source | One layer holds three kinds of check, and the page had called every one of them a quote check, including comparisons with a public source that quoted nothing |

### 2026.09.30, written 2026-09-26

| Change | Reason |
|---|---|
| A free card is written when its band or a flag changes, when its composite falls by 0.020 or rises by 0.050, or once a week with new handshakes behind it; it had been written on any move of 0.010 or once a day | Most free cards were written because a day had passed or the bound had tightened with more handshakes, 26,000 a day for web endpoints and 6,000 for servers, a log rather than a feed. Over the fortnight to 2026-09-26 the new rule writes 98,622 web cards where the old one wrote 373,218, and 37,310 server cards where it wrote 88,058, and it still writes a fall at once |
| A card is worked out again when something new arrived for it (a paid call at once, a handshake after 6 hours, a usable server look after 12), and weekly however quiet; it had been every 6 hours for an endpoint and every 24 for a server whatever had arrived | Measured 2026-09-26: 10,090 endpoints were due by the clock and 3,923 had anything new. Nothing new cannot change a card but by samples leaving the window, which the weekly look covers, and the grader's work now follows what arrives rather than how many endpoints are listed |
| A free look is due every 4 hours for an endpoint somebody needs, every 12 for one offering terms, and backs off to at most 7 days for one that stopped; a server behind a key waits 3 days, and the one due soonest goes first | The sweep looked at every endpoint in turn, 1.6 times a day each, whether an agent had asked about it or it had answered 404 for a week, and 8,500 of 22,041 remote servers were behind a key or gone while the 11,939 readable ones were looked at 0.79 times a day. At today's pace readable servers get about 40% more looks, and so more samples on their cards |
| Handshakes and server looks stay in the database six months and free cards three, then move a day to a file in the evidence store, listed at `/v1/archive` with the hash of each file; receipts, outcome records, corrections and paid cards never move | At 36,000 handshakes and 20,000 free cards a day the tables grow by about 100 MB a day, and nearly every read wants the last month. A file a stranger can fetch and hash keeps every row as reproducible as it was, and a count kept as rows arrive keeps every total whole |

A scorecard names the weights version and the verifier version it was produced under. This page
is a third thing that can change, so it carries its own version and says what moved.

### 2026.09.29, written 2026-09-26

| Change | Reason |
|---|---|
| A buyer's published calls can pull a component down and never push it up; weights version 2026.09.6 | A seller buying its own endpoint through Teppi gets its price back, so each call it publishes costs it only the fee, and across many wallets they read as many buyers. Each component is now worked out on every paid call and again on Teppi's probes alone, and the card carries the lower of the two. No published call is in the record yet, so no card moves on that; the version moves every bootstrap seed, which shifts some latency and price bounds in their last places |
| Burn in runs until 34 samples sit in the ninety day window, at 2.3 a day, and returns whenever old samples leave the window short of that | Twice a week fills about 26 samples in ninety days, against the 30 a letter needs, so past the first month's samples a letter had a one in five chance of surviving and would have lapsed around day 116 with nothing about the seller having changed. Burn in also reaches a letter in about fifteen days rather than thirty, on 34 samples rather than 45 |
| Each payout address somebody pays gets 1 paid call about every 18 days, on a float of its own | Keeping the money and answering nothing is a fact about an address, and only a paid call sees it. A letter for all 13,076 payable endpoints would cost about a thousand dollars a month; one look at each of their 1,044 addresses every eighteen days costs about ten, and a letter's own float never pays for it |
| The pool is chosen among endpoints somebody wants | A grade nobody reads is money spent on no one. The index's call count was already required when it published one; now an endpoint with no count needs a purchase through Teppi or an agent's question instead, and either of those also brings in one the index calls quiet. Teppi's own endpoints stay as coverage |

### 2026.09.28, written 2026-09-26

| Change | Reason |
|---|---|
| A cited page that turns out to be a bot challenge answered with a 200 is set aside, the way a refused page already was; verifier 2026.09.4 | A wall that answers 403 was always set aside, since it says nothing about the quote. Some walls answer 200 with a script and almost no text in place of the page, and those were read as the page, so a quote the seller had right read as a quote that was not there. Found on 2026-09-26 in one of our own answers: four quotes from a site behind such a wall read as four misses while the same answer's other four held. A page now reads as a wall when it carries a challenge's own script and almost no text of its own; nothing about a page that could be read has changed |

### 2026.09.27, written 2026-09-25

| Change | Reason |
|---|---|
| A listing the class words do not place is placed by a second, weaker list, read only when the first names nothing | A card's latency is scored against the median for its class, and a fifth of listings had no class, so text utilities, price feeds and flight lookups were scored as each other's peers. The second list places 1,245 of those 4,345 and moves no listing that already had a class. The medians of the classes they joined or left moved with them, by up to 457 ms for paid calls and 4 ms for handshakes, and one published letter crosses a band on it, from C to B at 0.799 to 0.802. Every card names the median it used, so each one still reruns from the card alone |

### 2026.09.26, written 2026-09-25

| Change | Reason |
|---|---|
| A held-out check can ask whether an answer written as prose states a figure, within a tolerance, or says given words; verifier 2026.09.3 | A seller that answers in sentences from sources could not be graded at all: its excerpts are its own rendering of each page, so checking them as quotes would call formatting a lie, while its answer states a figure anyone can hold it to |

### 2026.09.25, written 2026-09-24

| Change | Reason |
|---|---|
| A buyer's published call enters the record, as a source of its own, with no correctness, and a letter still needs 30 probes | Buying through Teppi on delivery started this day. A call its buyer publishes is the one kind of paid evidence a seller cannot tell from its other traffic, so it belongs in the record; it answers no question a held-out task could, so it cannot stand in for one. Weights version 2026.09.5 counts only probes toward the letter threshold, which leaves every card with no buyer's call in it exactly as it was |

### 2026.09.24, written 2026-09-24

| Change | Reason |
|---|---|
| A failed answer whose settlement is unread is scored for honesty only once the chain has been read | Until this version an unread settlement was scored as nothing charged, so a failure the seller named no settlement for read as an honest refusal. Twenty five published records stood on that. Read against the chain on 2026-09-24, twenty four had moved nothing, so their figure was right, and one had moved the full 0.001 USDC: the seller answered 401 and named its transaction in a header the parser of that first day did not read. That record is withdrawn under `our_record`. The verifier moves to 2026.09.2, where such a failure's honesty is left unknown, and the prober holds it until the chain says |
| The chain is read once the authorization has expired, not after a fixed 30 minutes | The authorization is signed for as long as the seller's terms allow, and of thirty one endpoints paid in three weeks whose terms were kept, three allowed more than 30 minutes, one of them seven days. A settlement made after the fixed wait would have read as nothing moved |

### 2026.09.23, written 2026-09-23

| Change | Reason |
|---|---|
| A correct answer that misses its published schema is no longer counted as a failed delivery | An endpoint answered twelve paid calls correctly at exactly its listed price, and each response carried one `null` where the schema its own server publishes says string: the top entry in a ranking had no display name. The shape check was right to fail it, and schema conformance read zero. The verdict then counted that same miss as a failed delivery, so honesty read zero too, and the endpoint was eighteen days from a published F for correct data at the right price. One defect was being charged twice. The deepest check that scored the answer now decides whether it failed, and the shape decides only when nothing deeper could run. The verifier moves to 2026.09.1 |
| A fifth fault, `our_verdict`, for an entry whose checks were right and whose figure was not | None of the four fitted. The request was right, the address was the seller's, the transcript is kept, and what the answer was scored against is the schema the seller's own server publishes, so calling it `our_expectation` would have said something false. What was ours and wrong was the conclusion drawn from correct checks. The twelve records are withdrawn under it, and the three beside them stand, since the current verifier scores those the same way |

### 2026.09.22, written 2026-09-22

| Change | Reason |
|---|---|
| Paid evidence is scored over ninety days, a handshake over thirty, and every card says which window it used | A letter needs thirty paid samples, and past its first month an endpoint is paid for twice a week, which is nine in thirty days. Every letter would have been taken away a few weeks after it was issued, not because anything about the seller changed but because the window outran the rate. The handshake side is unchanged, since it arrives twice a day. `WEIGHTS_VERSION` moves to 2026.09.4 since the samples behind every paid number moved |
| The six-call stop and the settled-below-the-band refusal both wait for a letter when every miss in the run settled money | An endpoint that took 24 payments in four days and answered none of them was stopped at six, so it stood permanently unrated on a card of one sample. Where the seller keeps the money the free layer sees nothing of it, so the paid call is the only record there will ever be, and it is worth paying for until the record can say so |
| `subcent_refused_sellers` joins the market findings, counted off the reason the facilitator gave on the receipt | Reading the transcripts behind a D due 2026-09-29 found six paid calls in a row refused with `subcent_quota_exceeded` by the seller's own facilitator while nine other sellers' sub-cent payments settled the same days, and nothing published counted how many sellers that happens to |
| A paid call nobody answered is recorded once the chain has been read, with honesty from what moved | Until this version a paid request that timed out closed its receipt with the settlement unknown and wrote no record at all, so an endpoint that took the payment and answered nothing was invisible to its own card. Reading the chain by hand found one that had done exactly that 24 times in four days, each settled, while its card stood on one sample. Those calls are recorded under this rule with their receipts left as they were closed, since the record does not rewrite a receipt, and the evidence names the transaction the chain showed |

### 2026.09.15, written 2026-09-20

| Change | Reason |
|---|---|
| The replay step records `repeated` when the second answer is byte for byte what the payment bought | Teppi's own gateway answers a repeated payload with the answer it already bought, marked as such, so a buyer whose connection dropped is not charged twice. The first paid probes of it read `accepted`, the same word as a seller that did the work again for free, and the market count would have named Teppi among them. Those four records stand as written. From here the check compares the bytes, which anyone holding both transcripts can do too |

### 2026.09.14, written 2026-09-19

| Change | Reason |
|---|---|
| `our_expectation` covers a schema we scored against that the seller never declared | Fifty seven listings document their error answers beside the sample response, and the index wraps that whole object in a schema of itself. Two of them had been paid twenty six times and every response was scored against a contract requiring a field named `type`, so schema conformance and honesty read zero on each and one was ten days from a published F. The wrapper is now recognised whatever the seller documented beside the sample, and the twenty six records are withdrawn |
| Named the fourth fault, `our_record`, for an entry whose transcript was never kept | Eleven paid records from the first two hours of probing on 2026-08-31 cite hashes the store never held. The evidence route already answered 410 for them and said why, but the composite still counted them, and seven sat in one paid card of twenty two samples. A claim nobody can rerun is withdrawn from every grade computed after the correction, and the check that reads the store now fails on any such record no correction owns |

### 2026.09.13, written 2026-09-19

| Change | Reason |
|---|---|
| Remote mcp servers carry a handshake card, scored the same way from their own sweep | The method was written in transport neutral terms from the start and only one package's field names said otherwise. Now a stranger can read what a server card stands on, why a walled server has none, and which median its latency was measured against |

### 2026.09.12, written 2026-09-19

| Change | Reason |
|---|---|
| A handshake card's schema_conformance is the share of declared schemas that are well formed, not half marks per side | The old expression gave a seller that declared inputs and no outputs half a failure for a field that is optional. No published number moved, since the http sweep has not yet recorded a declaration; the first cards to carry one are the remote mcp servers, where 82% of listings declare inputs and few declare outputs |

### 2026.09.11, written 2026-09-19

| Change | Reason |
|---|---|
| A record a correction names leaves every grade computed after the correction | Corrections were published beside an entry and the composite kept counting it, so admitting a request was ours would have left the letter it produced standing. The first case was a swap quote endpoint sent a bare GET with none of its four required parameters twenty six times, answered 400 every time, and two days from a published F for it |
| A paid call answered with anything but a 2xx counts toward the six that stop paid probing, the same as one never answered | Twenty six 400s cost the same twenty six cents as twenty six silences, and the retry ceiling only counted the silences |

### 2026.09.10, written 2026-09-18

| Change | Reason |
|---|---|
| A paid card's latency is measured against paid calls to the rest of its class, and every card names the median it was measured against | Until 2026-09-19 a paid call's 95th percentile was scored against the class median of free 402 round trips, which a delivery cannot match, so every paid card carried a latency of zero whatever the seller did: thirteen capabilities with fifteen or more samples, thirteen zeros. The median was not on the card either, so the one component a reader could not rerun was the one that was wrong |

### 2026.09.9, written 2026-09-17

| Change | Reason |
|---|---|
| Wrote down the replay step, the counts it feeds, and the paper that names the failure from the other side | The check had run since 2026-09-11 and published a count, and this page never said so, so a reader of the count had no way to learn what was actually sent |
| Stopped describing the wallet pool as unpublished | A pool funded by a fan-out from one address is readable from any point of it, and a sentence that leaned on it being unknown was a sentence a reader could disprove |

### 2026.09.8, written 2026-09-17

| Change | Reason |
|---|---|
| Named the third fault, `our_expectation`, and where the whole correction log and its rate are served | A held-out answer can be wrong, and a page that could not say so was asking to be believed about the one thing a disputed grade turns on |

### 2026.09.7, written 2026-09-11

| Change | Reason |
|---|---|
| Said how a numeric field's pass can be proven, not just asserted | A correctness match against a held-out value was the one thing on this page a stranger could not recompute themselves. A zk proof against a commitment published before the draw closes that gap |

### 2026.09.6, written 2026-09-09

| Change | Reason |
|---|---|
| Said why an outcome-priced signal is the one worth publishing, citing Bauer, arXiv:2607.26327 | Generative output made credentials and sample answers cheap to fake, which is the exact condition under which that paper shows only an outcome-contingent signal keeps separating real delivery from a plausible one |

### 2026.09.5, written 2026-09-08

| Change | Reason |
|---|---|
| Said what this is not, before saying what it is | A reader who found this page through an MCP registry has likely also found projects that measure protocol and schema compliance from a free handshake. Nothing here was clear about which kind of claim this page makes |

### 2026.09.4, written 2026-09-07

| Change | Reason |
|---|---|
| Added the listing defects a buyer can check before paying | A grade needs paid samples and time. Whether a url can be called as published needs neither, and 1,310 of the endpoints listed today fail one of these four checks |
| Said plainly that our own bad request never appears there | A 400 to a body we chose is a fact about us, and 770 endpoints would have been blamed for one |

### 2026.09.3, written 2026-09-07

| Change | Reason |
|---|---|
| Rates are bounded by a time-uniform confidence sequence instead of the Wilson interval | The bound is republished every time evidence arrives and a feed and a watcher read every publication. Wilson promises 95% at one size chosen in advance; simulated over 200 looks at a true rate of 0.9 it rose above the truth in 11% of runs, and at 0.7 in 16%. The replacement stayed inside its promise |
| Says the new bound is wider, so numbers are lower and letters later | It is the price of a bound that holds however often it is read, and a reader is owed the price as well as the benefit |
| Rates are no longer trimmed | Trimming cuts the extremes, and for a rate the extremes are the failures. Ninety nine successes and one failure, trimmed, read as one hundred successes |

### 2026.09.2, written 2026-09-03

| Change                                                                                         | Reason                                                                                                                                                                                                                     |
|------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Says a draw becomes a probe only when a wallet is eligible, and that the settled rate is lower | The page said new capabilities are probed once a day, which described an intention as a fact. The rotation rule pauses rather than reuse a wallet, and measured against the record about two probes in five find none free |
| Points the reader at the sample count and effective sample size on the card                    | Those move with the real rate, so they stay true when a sentence about cadence would not                                                                                                                                   |

### 2026.09.1, written 2026-09-03

| Change                                                                                         | Reason                                                                                                                                                                                       |
|------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| Says no *correctness or honesty* number exists without a settled payment, rather than no grade | As written it contradicted the free tier defined higher up the same page, which pays nothing and does publish a grade                                                                        |
| Added this version and this section                                                            | A card cites this page by name. Without a version the page a reader fetches is today's, whatever their card was signed against                                                               |
| Cards signed before 2026-09-03 cite `teppi.xyz`                                              | That host has never resolved. The page has always been served at `api.teppi.xyz`, which is what the manifest and the discovery files point at, and what cards signed after that date carry |

### 2026.08.1, written 2026-09-03

| Change          | Reason |
|-----------------|--------|
| First published |        |