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.