SERV Hackathon 02 · Kite track Record signed Base mainnet · USDC GitHub

What this does not prove.

Most of the record is checkable by someone who does not trust this program. One part is only half-checkable, and it is the part the product is about. This page is the whole of that, in our own words.

The model

The payments are chain-verified. The refusals are corroborated by the payment network's own ledger, but not attested by the agent. That is the one asymmetry in the product, and it is deliberate that it is visible rather than buried.

What a third party can check without trusting us

  • The payments. Each purchase carries a transaction hash. Capsule reads the transaction from Base when it makes the proof, checks that a transfer of exactly the expected amount of USDC was made, and checks that the sender was the session's own wallet. A reader can do the same with curl and a block explorer. The answer carries the moment the chain was read, so a reader can see how old it is.
  • The record's integrity. The decision log is a keccak-256 hash chain: each record commits to the one before it. Editing an earlier decision breaks every link after it, and the verifier names the record that broke. The head is signed with the secp256k1 key Kite publishes for the agent's DID, and that key is fetched live from Kite over plain HTTPS, so the signature can be checked against Kite rather than against us.
  • The budget. The session that produced the record is inside the hash chain, so the per-call cap and the total budget are covered by the signature. They cannot be edited without breaking the head.
  • The refusals, against the payment network's own record. The Kite Passport keeps a ledger of every x402 payment it settles, with the transaction for each one, and of every spending session the owner approved with a passkey. A refusal leaves no payment behind, so that ledger corroborates a refusal by the absence of the thing a payment would have left, in a record this project did not write. /evidence.json holds the reconciliation for the recorded run: every attempt matched by session, address and amount, with the disagreements counted.

What a third party cannot check

  • The refusals, finally. The ledger shows that the network was not charged for the two purchases the log says were refused. It does not say why, and it is not a statement the agent signed: there is no transaction that says "I was refused". The owner could rewrite the log and re-sign it, and the ledger would still show only that no payment happened. Until the agent writes an attestation transaction per refusal, that part of the record is the owner's account, checked against someone else's silence.
  • The link between the paying wallet and the agent's DID. Kite records it in the session and the agent-registration records, and those records are not readable by a third party. We publish both addresses and assert each separately rather than claim a binding we cannot show.
  • That the prices are the real prices. A price comes from the merchant's x402 challenge, and the amount that gets signed is the amount the merchant asked for. The on-chain transfer confirms that amount was paid; it does not confirm the merchant charged a fair price for the data.

What would close the gap

One attestation transaction per refusal, signed by the agent and posted on chain, would make a refusal something the chain carries rather than something the owner says. It costs a few cents of gas and one wallet, and it has not been done. It is the first thing on the list, not a footnote.

Everything else in this repository is checkable today, with the tools in the README, against the live deployment, without an account.

What this program can and cannot do with money

The cap is enforced outside the process that wants to spend. The code in this repository never filters the menu by budget, never holds a key that can move funds on its own, and never decides what an agent may afford. A Kite Passport session (approved with a passkey, held in the Passport's backend) is the only thing that can release funds, and it refuses in its own code with its own error codes. That is the whole difference between this and the common pattern, where the agent caps itself in a config file it can read.

Hostile input

/verify fetches a URL a stranger gives it, which is the one place in this project where the input is hostile. The fetcher only takes https; it resolves the host once and connects to the address it checked, so there is no window in which a name can be re-pointed at a private address; it refuses every non-public address, including the cloud metadata address; it re-checks every redirect hop; and it caps the size and the time of the read.