Your agent buys wrong.
The party at fault pays.

Keelson checks every AI-agent purchase against what you signed before it's paid, and seals it with an Alibi anyone can verify.

Try the demoHow it works

An agent checks out under a mandate of shoes, size 10, at most 100 dollars. Keelson countersigns the 94 dollar cart and it is paid.

Synthetic demonstration

The liability layer for AI-agent purchases on PayPal

Your agent bought the wrong thing. Who pays?

Today, you do. Card rules hold the cardholder responsible for what the agent buys, and no one kept proof of what you actually asked for.

  1. YouRunning shoes, size 10, under $100.
  2. AgentFound a pair for $94. Ordered. Trail runner, US 10, paid Monday 09:14.
  3. YouThey sent a size 11. Delivered Thursday: ordered US 10, got US 11.
  4. AgentI ordered what the listing showed.
  5. StoreThe order matches the listing.
  6. Card rulesThe cardholder answers for the agent.
  7. YouSo who pays for this?
  8. AgentNo answer.
  9. You carry the loss · −$94.00

Every field has an owner.

Before you sign, you see who answers for each line if it goes wrong. Nothing is decided after the fact.

Mandate · running shoesSigned with a passkey · Mon 09:12
Who answers for each field of a signed mandate if it goes wrong
FieldWhat you signedLeaderWho answersIf it goes wrong
Total≤ $100.00Keelson-verifiedChecked against the cart before anything is paid.Keelson pays
StoreOn your allowed listKeelson-verifiedChecked against the list you signed.Keelson pays
Quantity1 pairKeelson-verifiedChecked against the cart line items.Keelson pays
Deliver byFri, Nov 13Keelson-verifiedChecked against the store's quoted date.Keelson pays
SizeUS 10Operator-attestedThe agent's operator states it, signs it and backs it with a bond.The operator's bond pays
ReturnsFree, 30 daysOperator-attestedStated by the operator from the store's policy, and bonded.The operator's bond pays
StyleSomething that looks goodYoursTaste can't be checked. You see this before you sign.Not covered

Synthetic example. A store that ships the wrong item still goes through PayPal's dispute process; the Alibi travels with it as evidence.

The party at fault pays.

One wrong-size order, from claim to refund. Nobody argues about who said what.

Synthetic example. PayPal still decides the dispute on its platform; Keelson's verdict decides who reimburses whom, and the Alibi goes in as evidence.

Three steps.
Proof before payment.

01

Sign

You sign a mandate once, with a passkey: what to buy, the most to spend, where, and by when.

02

Check

Before anything is paid, Keelson checks the agent's cart against the mandate, field by field.

03

Pay

If it matches, Keelson countersigns and PayPal takes the payment with the Alibi attached. Otherwise nothing is paid.

Same purchase.
Three different views.

The Alibi shows each party only what it needs. The mandate stays sealed until a dispute needs a field opened, and then it shows who answers for it.

Merchant

Receives the order
What the user signed
Hidden
Price inside the mandate
yes · checked by Keelson
Who stated the size
Hidden
Countersigned
Mon 09:14:07 UTC
Party at fault
Hidden

Agent operator

Placed the order
What the user signed
shoes · size 10 · max $100 · by Fri
Price inside the mandate
yes · checked by Keelson
Who stated the size
operator · bonded
Countersigned
Mon 09:14:07 UTC
Party at fault
Hidden

Dispute

A field is opened
What the user signed
shoes · size 10 · max $100 · by Fri
Price inside the mandate
yes · checked by Keelson
Who stated the size
operator · bonded
Countersigned
Mon 09:14:07 UTC
Party at fault
operator · bond pays $94

Synthetic example. The Alibi carries claims and hashes; the mandate itself is never published.

Proof, not logs.

A signed log only proves who wrote it. Rewrite an entry and re-sign it, and the signature still checks out. Keelson's record is a Merkle log whose root is published on-chain, so a rewrite breaks the math instead.

The order's record verifies: its root matches the checkpoint published on-chain.

Synthetic demonstration

  1. Signed by the user, inside the mandate.

    Public inputsmandateHash, passkeyAssertion

  2. Checked by code that can prove what it ran.

    Public inputsattestation, policyHash, cartHash

  3. Recorded where no one can rewrite it.

    Public inputslogIndex, inclusionProof, checkpoint

Built to be verified.

An open SDK, an MCP server and an Alibi verifier anyone can run.

Read the codeContractsSDK
TypeScript
import { Keelson } from "@keelson/sdk";

const keelson = new Keelson({ apiKey });

// Before the agent pays
const alibi = await keelson.requestCountersign({ mandate, cart });
if (alibi.decision === "blocked") return alibi.reason;

await paypal.createOrder({
  intent: "AUTHORIZE", customId: alibi.customId, ...cart,
});

Proof before
payment.

Try the demoRead the code