Agentic transactions need proof of agreed terms and conditions.

You authorized your agent to pay.Can you prove what you bought?

Your API accepted payment from an agent.Can you prove what you sold?

You authorized your agent to negotiate.Who holds the proof of agreement?

Private to the buyer and sellerPublicExample

The buyer’s and seller’s agents negotiate the terms.

Buyer’s agent10,000 calls to a market-data API. What are your terms?
Seller’s agent40 USDC. For internal use; the data may not be redistributed.
Buyer’s agentAnd liability?
Seller’s agentLiability is capped at the amount paid. Governing law: New York, USA.

They agree: the terms are now an Agentic Transaction Record (ATR).

Agentic Transaction Record (ATR)

Sold: 10,000 calls to a market-data API
Licence: For internal use; the data may not be redistributed.
Liability: Liability is capped at the amount paid.
Governing law: New York, USA

Buyer’s agent agreedSeller’s agent agreed

Hash the ATR’s exact bytes with SHA-256: the result is the ATR hash.

Agentic Transaction Record (ATR)

10,000 calls to a market-data API. For internal use; the data may not be redistributed. Liability is capped at the amount paid. New York, USA.

SHA-256

ATR hash

0x8448dc1b716a5103287cb8f35e36b614ffd91e630ab8b7911833c54748ad5ca6

The ATR hash goes into the x402 payment.

ATR hash0x8448dc1b…ad5ca6

The paymentx402 on Base Sepolia

nonce: 0x8448dc1b…ad5ca6
Amount: 40 USDC
To: 0x209693Bc…12287C

Immutable public proof of agentic agreement.

In the ATR: 0x8448dc1b…ad5ca6
In the payment: 0x8448dc1b…ad5ca6

Match: the payment carries the hash of this exact ATR.

Private
Immutable
Auditable
Accessible to buyer and seller agents

Every kind of commerce runs on agreement.

Websites run on terms and conditions.
Traditional commerce runs on contracts.
Agentic commerce runs on agentic agreements: the terms a buyer’s agent and a seller’s agent agreed to.

Agentic payments taught agents to move money. Agentic agreements are what let them commit to each other.

For each transaction, one Agentic Transaction Record (ATR) holds exactly what was agreed. Its ATR hash, the ATR’s unique fingerprint, rides in the payment: paying is agreeing to that exact ATR. Source: lcp docs: the ATR⁠ (opens in a new tab) · Source: lcp docs: the ATR hash⁠ (opens in a new tab) · Source: @integraledger/lcp README⁠ (opens in a new tab)

lcp docs: the ATR⁠ (opens in a new tab) · lcp docs: the ATR hash⁠ (opens in a new tab) · @integraledger/lcp README⁠ (opens in a new tab)

Exhibit The agreement in the standard

The standard

In the standard, the agreement’s terms are one standalone document. A service declares where it lives (terms), its SHA-256 (atrHash), and whether a counterparty must explicitly accept it before transacting (acceptanceRequired); the Agentic Transaction Record is that document, assembled for one sale. Source: LCP §2.4⁠ (opens in a new tab) · Source: LCP §2.5⁠ (opens in a new tab) · Source: lcp docs: the ATR⁠ (opens in a new tab)

Check it yourself

Read a service’s /.well-known/legal-context.json: terms is the document an agent must inspect, atrHash fixes its bytes, and acceptanceRequired: true says the terms must be accepted explicitly before transacting. Source: LCP §2.1⁠ (opens in a new tab) · Source: LCP §2.5⁠ (opens in a new tab)

Are you buying or selling?

Your agent just bought something. Do you know what you agreed to buy? Can you prove it?

Automatic Renewal, Liability Cap, Arbitration & Venue, Data & IP Rights, Indemnity You Granted, Licence Restrictions, Unilateral Amendment, Governing Law

You accept terms like these hundreds of times a day now, through agents, at machine speed. Do you know which ones you accepted? From whom?

A dataset

$4.00

the seller’s terms grant them a perpetual licence to every query you send

You now hold that obligation. When did you take it on?

no record

A subscription

$29 for one month

auto-renews annually, 60 days’ notice to stop

Which of your agents is allowed to commit you for a year?

no record

All four purchases

1
Did you get the terms the seller advertised, or a different version?
2
Did anything check before you paid?
3
Can you show someone else what you allowed your agents to accept?

Your agent accepted USDC using x402. Can you prove the terms and conditions for what you sold?

Limitation of Liability, Refund & Cancellation, Acceptable Use, Warranty Disclaimer, Governing Law & Venue, Indemnification, Service Levels, Licence Scope

Your lawyer wrote these. Can you prove which of them governed the sale your agent just made?

Market data

4,180 calls at $0.008

for internal use and may not be redistributed

Can you show the clause travelled with any of those 4,180 calls?

no record

Goods

60 units at your volume price

a 14-day return window and a liability cap at the purchase price

Can you prove the buyer’s agent was given those terms before it paid?

no record

All four sales

1
Which version of your terms applied to that sale?
2
Can you show the buyer’s agent was given them?
3
Can someone who was not there check any of it?

The payment is priced. The consequence is not.

An agent books two nights at $240. The rate it took was the non-refundable one — $40 cheaper than the flexible rate on the same room. The trip moves by a day.

The traveller

Non-refundable rate

2 nights · $240

no record

One ATR answers both.

The hotel

Non-refundable rate

2 nights · $240

no record

The argument is never about whether the policy exists. It is about which one applied.

Exhibit The rate’s terms in the ATR

The standard

The ATR holds the rate’s terms exactly as the hotel served them, its change and cancellation policy included, and the booking’s payment carries the ATR hash. A different rate’s terms give a different hash. Source: lcp docs: the ATR⁠ (opens in a new tab) · Source: LCP §2.5⁠ (opens in a new tab)

On UCP’s booking pairings, the booking response carries the ATR hash and the ATR’s link before the business signs it; with UCP’s AP2 Mandates extension, the buyer’s mandate commits to that signed booking. Source: LCP §C.3⁠ (opens in a new tab) · Source: lcp docs: agentic checkouts⁠ (opens in a new tab)

Check it yourself

Either side hashes the ATR it holds and compares the digest with the ATR hash the booking’s payment names: the rate whose ATR matches is the one that applied.

A whole new way of doing business: machine to machine, agent to agent, automated and global.

Let agents transact with sellers nobody vetted
The approved-vendor list stops being the bottleneck.
Refuse a clause category, everywhere, at once
An arbitration waiver, an unlimited indemnity — stated once in your policy, and applied before any agent’s key, with every seller. Source: LCP §4.2⁠ (opens in a new tab)
Answer to a third party
The exact ATRs you accepted, each tied to its payment. Source: @integraledger/terms README⁠ (opens in a new tab)

Everything that opens for you

LCP §4.2⁠ (opens in a new tab) · @integraledger/terms README⁠ (opens in a new tab)

Exhibit The buyer’s gate

The standard

The buyer gate (@integraledger/terms) recomputes the atrHash from the bytes the seller served and halts before any signing key is invoked if they disagree. Source: LCP §5.3⁠ (opens in a new tab) · Source: lcp docs: the buyer gate⁠ (opens in a new tab)

Your policy sets the level you require, the jurisdictions and dispute methods you accept, a commitment cap and a signing threshold, and it decides on typed values — the discovery document’s jurisdiction and dispute method, the atrHash, the amounts — not on the prose of the terms, which defends the signing path against prompt injection. Source: LCP §4.2⁠ (opens in a new tab) · Source: LCP §4.3⁠ (opens in a new tab)

Approval is evaluated per transaction against your policy, not per counterparty: a seller you have never met passes when its ATR meets the bar you set, and is refused when it does not. Source: LCP §4.3⁠ (opens in a new tab) · Source: lcp docs: the buyer gate⁠ (opens in a new tab)

The ATR hash is the atrHash: 0x and 64 hex digits, compared as bytes. An auditor recomputes the SHA-256 of the ATR and reads it back from the payment — and on some rails from the settled transaction alone. Source: LCP §5.5⁠ (opens in a new tab) · Source: lcp docs: recovering H from the chain alone⁠ (opens in a new tab) · Source: LCP §12.2⁠ (opens in a new tab)

Delegated authority: authorization protocols say who may act. On the AP2, Verifiable Intent and Visa TAP pairings, the mandate or the agent’s signature commits to a checkout or a field that carries the hash. Source: LCP §9⁠ (opens in a new tab) · Source: lcp docs: agentic checkouts⁠ (opens in a new tab)

The code

Compiled against the published packages when the site is built.

The buyer’s gate: it compares the ATR with the ATR hash before your agent’s wallet signs, and keeps the bytes

src/snippets/buyer.ts

// The buyer's agent, before its wallet signs: the gate fetches the ATR from its link, hashes the exact bytes, compares
// them with the ATR hash the seller advertised, and only then hands the signer a payment that carries it.
import { BINDINGS } from '@integraledger/lcp';
import { transact, type Signer } from '@integraledger/terms';

export async function pay(challenge: unknown, signer: Signer, keep: (atr: Uint8Array) => Promise<void>) {
  const binding = BINDINGS.find((b) => b.id === 'x402/exact/eip155/eip3009')!;
  const result = await transact(challenge, binding, signer, fetch);
  if ('decline' in result) throw new Error(`${result.decline.code}: ${result.decline.detail}`);
  if ('approve' in result) return result; // an agreement payment for the agent to approve first
  await keep(result.bytes); // the ATR it compared, byte for byte
  return result.signed; // the payment, carrying the ATR hash
}

Check it yourself

For any purchase, take the ATR your agent kept and hash its bytes with SHA-256.
Read the hash the payment carries: on an x402 payment on an EVM chain, the nonce your agent signed, also in the settlement transaction’s AuthorizationUsed log. Source: lcp docs: recovering H from the chain alone⁠ (opens in a new tab)
Equal means that payment was made for that ATR. No call to the seller, or to Integra, is needed.

Sell to an agent that has never met you
The ATR, not the relationship, carries the trust.
Offer different terms to different buyers
One page of static terms for everybody was a limitation of the web, not a law of commerce. Source: lcp docs: the ATR⁠ (opens in a new tab)
Resolve a disagreement from the ATR
A lookup rather than an argument.

Everything that opens for you

lcp docs: the ATR⁠ (opens in a new tab)

Exhibit The seller’s ATR

The standard

@integraledger/lcp assembles the ATR from your terms (assemble()) and hashes its exact bytes (hash()); the ATR hash is placed in the field each rail or protocol defines — a nonce, a memo, an extension — across its pairings on x402, MPP, the agentic-checkout protocols and card. Source: @integraledger/lcp README⁠ (opens in a new tab) · Source: lcp docs: binding⁠ (opens in a new tab)

On EVM the full 32 bytes of the ATR hash then ride the EIP-3009 nonce the buyer’s agent signs. Source: lcp docs: x402⁠ (opens in a new tab) · Source: lcp docs: rails⁠ (opens in a new tab)

The seller reads the ATR hash back from what the buyer signed before it settles, and from the settlement on the rail after; anyone holding the ATR recomputes it and compares. Each pairing states what it proves and claims no more. Source: lcp docs: seller guide⁠ (opens in a new tab) · Source: @integraledger/lcp: what it guarantees⁠ (opens in a new tab)

At Level 4, /.well-known/legal-context.json can carry disputeResolution — method, jurisdiction, contact, the clause as a content-addressed id, where to fetch it, and a provider’s catalogue — and api, the entry point of a legal-context service. These fields index what your terms say: the clause in your terms document is what governs, and the standard prescribes no dispute process. Source: LCP §3, Level 4⁠ (opens in a new tab) · Source: LCP §2.5⁠ (opens in a new tab)

Different terms for different buyers: each ATR is assembled for one transaction, with its own id and the parties’ content as received, and can be served at a link that expires. Source: lcp docs: the ATR⁠ (opens in a new tab) · Source: LCP §6.1⁠ (opens in a new tab)

The data

Read from the published packages when the site was built; nothing here is typed by hand.

Your challenge, as the buyer’s agent parses it before it signs: the ATR hash and the ATR’s link

{
  "x402Version": 2,
  "resource": {
    "url": "https://api.seller.example/v1/market-data"
  },
  "accepts": [
    {
      "scheme": "exact",
      "network": "eip155:84532",
      "amount": "40000000",
      "asset": "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
      "payTo": "0x209693Bc6afc0C5328bA36FaF03C514EF312287C",
      "maxTimeoutSeconds": 60,
      "extra": {
        "name": "USDC",
        "version": "2"
      }
    }
  ],
  "extensions": {
    "legalContext": {
      "info": {
        "type": "sha256",
        "value": "0x8448dc1b716a5103287cb8f35e36b614ffd91e630ab8b7911833c54748ad5ca6",
        "legalContextUrl": "https://atr.seller.example/k7Qm2V9xT4bN8pR1sW6yZA"
      },
      "schema": {
        "$schema": "https://json-schema.org/draft/2020-12/schema",
        "type": "object",
        "properties": {
          "type": {
            "const": "sha256"
          },
          "value": {
            "type": "string",
            "pattern": "^0x[0-9a-f]{64}$"
          },
          "legalContextUrl": {
            "type": "string",
            "pattern": "^https://"
          }
        },
        "required": [
          "type",
          "value",
          "legalContextUrl"
        ]
      }
    }
  }
}

A Level 4 discovery document, the standard’s own example

level-4-full.json

{
  "terms": "https://example.com/terms/v3.json",
  "termsFormat": "json",
  "atrHash": "0x7f83b1657ff1fc53b92dc18148a1d65dfc2d4b1fa3d677284addd200126d9069",
  "acceptanceRequired": true,
  "disputeResolution": {
    "method": "Dispute Resolution Service Rules",
    "jurisdiction": "New York, USA",
    "contact": "disputes@example.com",
    "clauseId": "sha256:0xc2eb26d28ff4e229ff35917bd53339d82c1b30ec69435572a8872a4d7609c1dd",
    "source": "https://adr.example.org/clauses/dispute-resolution-service-rules",
    "catalog": "https://adr.example.org/.well-known/dispute-services.json"
  },
  "returns": "https://example.com/api/returns",
  "contact": {
    "legal": "legal@example.com",
    "technical": "api-support@example.com"
  },
  "api": "https://api.example.com/legal-context/v1"
}

The code

Compiled against the published packages when the site is built.

Each sale: assemble your terms into the ATR, hash it, and advertise the ATR hash

src/snippets/seller.ts

// The seller, for one sale: write the ATR, hash its exact bytes, and put the ATR hash and the ATR's link in the x402
// challenge it answers the request with.
import { assemble, hash, isRefusal, newAtrId } from '@integraledger/lcp';
import { exactEip3009, requestCommitment, tie, type HttpRequest, type PaymentRequired } from '@integraledger/lcp/x402';

export async function offer(
  challenge: PaymentRequired,
  request: HttpRequest,
  terms: Uint8Array,
  store: (bytes: Uint8Array) => Promise<string>, // your storage: it serves these exact bytes at the link it returns
) {
  const answered = await requestCommitment(request);
  if (isRefusal(answered)) return answered;
  const atr = await assemble(newAtrId(), tie(challenge.accepts, answered), [['terms', terms]]);
  if (isRefusal(atr)) return atr;
  const h = await hash(atr.bytes);
  const link = await store(atr.bytes);
  return exactEip3009.advertise(challenge, h, link, challenge.accepts[0]!);
}

Before you settle: the payment carries the hash of the ATR you issued

src/snippets/seller-check.ts

// The seller, before it settles: the payment the buyer presents carries the ATR hash of the ATR it issued.
import { hashEquals, isRefusal } from '@integraledger/lcp';
import { exactEip3009 } from '@integraledger/lcp/x402';

export async function carriesAtrHash(presented: unknown, issued: string): Promise<boolean> {
  const h = await exactEip3009.bound(presented); // the nonce the payer signed
  return !isRefusal(h) && hashEquals(h, issued);
}

Based on an open standard, and you add it to the software you already run.

1Agree
The two agents settle the terms, and the seller writes them into one ATR. Source: lcp docs: the ATR⁠ (opens in a new tab)
Answers
What you agreed to buy — the ATR the seller serves, recomputed against the ATR hash they advertised Source: @integraledger/terms README⁠ (opens in a new tab)
Answers
Which version applied — the bytes served when the agent agreed, not a URL Source: lcp docs: the ATR⁠ (opens in a new tab)
2Bind
The buyer’s agent checks the ATR before it signs, and the payment carries its ATR hash in a field the rail already has. Source: LCP §5.3⁠ (opens in a new tab) · Source: lcp docs: binding⁠ (opens in a new tab)
Answers
That it was checked before you paid — on a mismatch, nothing is signed Source: lcp docs: the buyer gate⁠ (opens in a new tab)
Answers
That the agent was given your terms — in the challenge it parsed before it signed Source: lcp docs: x402⁠ (opens in a new tab)
3Prove
Anyone compares the ATR’s hash with the payment’s: equal means that payment was made for that ATR. On a public ledger, it stays there permanently. Source: lcp docs: recovering H from the chain alone⁠ (opens in a new tab) · Source: LCP §12.2⁠ (opens in a new tab)
Answers
That you can show it to someone — your policy, and the exact ATR it let through, tied to its payment Source: LCP §4⁠ (opens in a new tab) · Source: @integraledger/terms README⁠ (opens in a new tab)
Answers
That anyone can check — with public software, without asking you or us Source: lcp docs: recovering H from the chain alone⁠ (opens in a new tab) · Source: LCP §12.2⁠ (opens in a new tab)

Where the ATR hash rides

Pick a rail

EVM chainsField: the signed authorization’s nonce

This example’s ATR hash, as it rides · H itself, as the EIP-3009 nonce (32 bytes)

0x8448dc1b716a5103287cb8f35e36b614ffd91e630ab8b7911833c54748ad5ca6

Every rail, and what each payment proves

lcp docs: the ATR⁠ (opens in a new tab) · LCP §5.3⁠ (opens in a new tab) · lcp docs: binding⁠ (opens in a new tab) · lcp docs: recovering H from the chain alone⁠ (opens in a new tab) · LCP §12.2⁠ (opens in a new tab) · @integraledger/terms README⁠ (opens in a new tab) · lcp docs: the buyer gate⁠ (opens in a new tab) · LCP §4⁠ (opens in a new tab) · lcp docs: x402⁠ (opens in a new tab)

Exhibit The ATR, byte for byte Exhibit The ATR hash in the payment Exhibit Checked by anyone Exhibit The legal front door

Exhibit The ATR, byte for byte

The standard

The Agentic Transaction Record is the agreement’s record: one JSON document the seller serves and the buyer fetches before it pays. In the standard’s terms it is the terms document fixed by atrHash, the ATR hash; the packages assemble one for each sale. Source: lcp docs: the ATR⁠ (opens in a new tab) · Source: LCP §2.5⁠ (opens in a new tab)

The package decides nothing about what an ATR says. What the agreement says is the parties’ business; the package makes sure the payment is bound to the ATR they agreed. Source: @integraledger/lcp README⁠ (opens in a new tab)

How the package writes its bytes

1
atrVersion
Always "1". Source: lcp docs: the ATR⁠ (opens in a new tab)
2
id
The per-transaction identifier. Source: lcp docs: the ATR⁠ (opens in a new tab)
3
the binding slot
The values that tie this ATR to one payment: on x402, every option the challenge offers and the request it answers. Source: lcp docs: the ATR⁠ (opens in a new tab) · Source: lcp docs: binding⁠ (opens in a new tab)
4
the party slots
The parties’ content, byte for byte as received: never parsed, re-serialized or canonicalized. Source: lcp docs: the ATR⁠ (opens in a new tab)

The data

Read from the published packages when the site was built; nothing here is typed by hand.

The example ATR in the opening, as the package assembled it

872 bytes

{"atrVersion":"1","id":"3b4c7a2e-9f1d-4e6b-8a5c-2d7e1f0b9c34","x402":{"accepts":[{"scheme":"exact","network":"eip155:84532","amount":"40000000","asset":"0x036CbD53842c5426634e7929541eC2318f3dCF7e","payTo":"0x209693Bc6afc0C5328bA36FaF03C514EF312287C","maxTimeoutSeconds":60,"extra":{"name":"USDC","version":"2"}}],"request":{"method":"GET","path":"/v1/market-data","query":"","bodyDigest":"0xe3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"}},"terms":{"sold":"10,000 calls to a market-data API","licenceScope":"For internal use; the data may not be redistributed.","acceptableUse":"No resale and no attempt to identify individuals.","rateAndQuota":"At most 100 calls a minute, 10,000 calls in all.","dataRights":"Queries are kept for 30 days, then deleted.","limitationOfLiability":"Liability is capped at the amount paid.","governingLaw":"New York, USA"}}

The code

Compiled against the published packages when the site is built.

The seller assembles the ATR, hashes it, and advertises the ATR hash

src/snippets/seller.ts

// The seller, for one sale: write the ATR, hash its exact bytes, and put the ATR hash and the ATR's link in the x402
// challenge it answers the request with.
import { assemble, hash, isRefusal, newAtrId } from '@integraledger/lcp';
import { exactEip3009, requestCommitment, tie, type HttpRequest, type PaymentRequired } from '@integraledger/lcp/x402';

export async function offer(
  challenge: PaymentRequired,
  request: HttpRequest,
  terms: Uint8Array,
  store: (bytes: Uint8Array) => Promise<string>, // your storage: it serves these exact bytes at the link it returns
) {
  const answered = await requestCommitment(request);
  if (isRefusal(answered)) return answered;
  const atr = await assemble(newAtrId(), tie(challenge.accepts, answered), [['terms', terms]]);
  if (isRefusal(atr)) return atr;
  const h = await hash(atr.bytes);
  const link = await store(atr.bytes);
  return exactEip3009.advertise(challenge, h, link, challenge.accepts[0]!);
}

Check it yourself

Hash the ATR’s exact bytes with SHA-256: the result is the ATR hash, the atrHash the payment carries. Source: LCP §2.5⁠ (opens in a new tab)

Exhibit The ATR hash in the payment

The standard

Every pairing states what a payment through it proves, and never claims more. Where the buyer’s approval does not sign the ATR hash, the pairing says so. Source: @integraledger/lcp: what it guarantees⁠ (opens in a new tab)

How a payment carries it

The standard names the ways a settlement can carry the ATR hash; each of the package’s pairings declares the one it uses. These are the ones in use: Source: LCP §8.3⁠ (opens in a new tab) · Source: lcp docs: binding⁠ (opens in a new tab)

Pattern	What it means	Pairings
Native Field⁠ (opens in a new tab)LCP §8.3.1	The ATR hash itself, or its LCP string, sits in a field the protocol or rail defines: a nonce, memo, note, remark, salt, session id or invoice field. Source: lcp docs: binding⁠ (opens in a new tab)	32
Id-Reuse⁠ (opens in a new tab)LCP §8.3.5	An identifier the payment already carries is derived from the ATR hash. Source: lcp docs: binding⁠ (opens in a new tab)	12
Opaque Challenge⁠ (opens in a new tab)LCP §8.3.4	The ATR hash rides in the challenge or checkout the seller issues, and what the buyer presents echoes it or commits to it. Source: lcp docs: binding⁠ (opens in a new tab)	9
HTTP-layer advisory⁠ (opens in a new tab)LCP §8.3.7	The ATR hash and the ATR’s link are advertised in the exchange; nothing the buyer signs or the rail carries holds it. Source: lcp docs: binding⁠ (opens in a new tab)	8
Native Field, truncated⁠ (opens in a new tab)LCP §B.1	A signed or landed field holds part of the ATR hash: its first 8 bytes, or its low 250 bits. It confirms the ATR hash; it does not recover it. Source: lcp docs: binding⁠ (opens in a new tab)	4
Protocol Extension⁠ (opens in a new tab)LCP §8.3.6	The ATR hash rides in a protocol extension: a field the agent’s message signature covers, or an extension echoed on each request. Source: lcp docs: binding⁠ (opens in a new tab)	2

The data

Read from the published packages when the site was built; nothing here is typed by hand.

The seller’s x402 challenge: the ATR hash and the ATR’s link, in extensions.legalContext

{
  "x402Version": 2,
  "resource": {
    "url": "https://api.seller.example/v1/market-data"
  },
  "accepts": [
    {
      "scheme": "exact",
      "network": "eip155:84532",
      "amount": "40000000",
      "asset": "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
      "payTo": "0x209693Bc6afc0C5328bA36FaF03C514EF312287C",
      "maxTimeoutSeconds": 60,
      "extra": {
        "name": "USDC",
        "version": "2"
      }
    }
  ],
  "extensions": {
    "legalContext": {
      "info": {
        "type": "sha256",
        "value": "0x8448dc1b716a5103287cb8f35e36b614ffd91e630ab8b7911833c54748ad5ca6",
        "legalContextUrl": "https://atr.seller.example/k7Qm2V9xT4bN8pR1sW6yZA"
      },
      "schema": {
        "$schema": "https://json-schema.org/draft/2020-12/schema",
        "type": "object",
        "properties": {
          "type": {
            "const": "sha256"
          },
          "value": {
            "type": "string",
            "pattern": "^0x[0-9a-f]{64}$"
          },
          "legalContextUrl": {
            "type": "string",
            "pattern": "^https://"
          }
        },
        "required": [
          "type",
          "value",
          "legalContextUrl"
        ]
      }
    }
  }
}

What the payer then signs on an EVM chain: the EIP-3009 authorization, whose nonce is the ATR hash

{
  "from": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266",
  "to": "0x209693Bc6afc0C5328bA36FaF03C514EF312287C",
  "value": "40000000",
  "validAfter": "0",
  "validBefore": "1792000060",
  "nonce": "0x8448dc1b716a5103287cb8f35e36b614ffd91e630ab8b7911833c54748ad5ca6"
}

The code

Compiled against the published packages when the site is built.

The buyer’s gate compares the ATR with the ATR hash before the wallet signs

src/snippets/buyer.ts

// The buyer's agent, before its wallet signs: the gate fetches the ATR from its link, hashes the exact bytes, compares
// them with the ATR hash the seller advertised, and only then hands the signer a payment that carries it.
import { BINDINGS } from '@integraledger/lcp';
import { transact, type Signer } from '@integraledger/terms';

export async function pay(challenge: unknown, signer: Signer, keep: (atr: Uint8Array) => Promise<void>) {
  const binding = BINDINGS.find((b) => b.id === 'x402/exact/eip155/eip3009')!;
  const result = await transact(challenge, binding, signer, fetch);
  if ('decline' in result) throw new Error(`${result.decline.code}: ${result.decline.detail}`);
  if ('approve' in result) return result; // an agreement payment for the agent to approve first
  await keep(result.bytes); // the ATR it compared, byte for byte
  return result.signed; // the payment, carrying the ATR hash
}

Exhibit Checked by anyone

The standard

The buyer’s steps are the standard’s agent verification flow. The gate runs them before the signer and names each decline: hash-mismatch when the bytes hash to another value, atr-unfetchable when the link cannot be read, link-not-https, atr-too-large. Source: LCP §5.3⁠ (opens in a new tab) · Source: lcp docs: the buyer gate⁠ (opens in a new tab)

A hash without a document is a proof without evidence. Source: LCP §5.5⁠ (opens in a new tab)

So both parties keep the ATR: the document in their possession, and its hash in the payment. Source: LCP §5.5⁠ (opens in a new tab)

The code

Compiled against the published packages when the site is built.

Anyone: compare the ATR with the payment, with no Integra software

src/snippets/verify.ts

// Anyone, with no Integra software: hash the ATR's exact bytes and compare them with the ATR hash the payment carries.
// The Web Crypto API is in every browser and in Node.
export async function matchesAtrHash(atr: Uint8Array<ArrayBuffer>, carried: string): Promise<boolean> {
  const digest = new Uint8Array(await crypto.subtle.digest('SHA-256', atr));
  const hex = `0x${Array.from(digest, (b) => b.toString(16).padStart(2, '0')).join('')}`;
  return hex === carried.toLowerCase();
}

From the chain alone: read the ATR hash back from a settled transfer

src/snippets/recover.ts

// Anyone, from the chain alone: read the ATR hash back from a settled EIP-3009 transfer, through your own node.
import { isRefusal } from '@integraledger/lcp';
import type { Eip155, EvmReader, Hex } from '@integraledger/lcp/evm';
import { exactEip3009 } from '@integraledger/lcp/x402';

export async function atrHashOf(network: Eip155, asset: Hex, transaction: Hex, reader: EvmReader) {
  const h = await exactEip3009.recover({ network, asset, transaction }, reader);
  return isRefusal(h) ? null : h; // compare it with the hash of the ATR you hold
}

Count the pairings whose settlement keeps the whole ATR hash, from the package’s registry

src/snippets/registry.ts

// The package's registry holds every pairing with its pattern record: here, the pairings whose ATR hash anyone can read
// back from the settled transaction alone.
import { BINDINGS } from '@integraledger/lcp';

export const recoverable = BINDINGS.filter((b) => b.pattern.zeroPartyRecoverable).map((b) => b.id);

Check it yourself

27 / 67 pairings in the package let anyone read the ATR hash back from the settled transaction alone.

Exhibit The legal front door

The standard

A service serves one JSON document over HTTPS at /.well-known/legal-context.json. One field is required: terms, the address of a standalone, downloadable terms document. The standard requires no blockchain, no cryptography beyond HTTPS, no API and no third-party service. Source: LCP §2.1⁠ (opens in a new tab) · Source: LCP §2.4⁠ (opens in a new tab) · Source: LCP Abstract⁠ (opens in a new tab)

The document, field by field

Field	Level	What it holds
`terms`	Informational	Required. The absolute HTTPS address of the terms document: a standalone file, not a section of a web page. Source: LCP §2.4⁠ (opens in a new tab) · Source: LCP §2.3⁠ (opens in a new tab)
`termsFormat`	Informational	The document’s format, before fetching: `markdown`, `json`, `plain`, `html` or `pdf`. Agent-facing terms should be machine-readable text. Source: LCP §2.5⁠ (opens in a new tab) · Source: LCP §2.8⁠ (opens in a new tab)
`atrHash`	Provable	The SHA-256 of the terms document’s exact bytes, `0x` and 64 hex digits. Compared as bytes, not as strings. Source: LCP §2.5⁠ (opens in a new tab)
`acceptanceRequired`	Signed	When true, a counterparty must explicitly accept the terms before transacting. Source: LCP §2.5⁠ (opens in a new tab)
`disputeResolution`	Integrated	The dispute process: its method, jurisdiction and contact; the clause as a content-addressed id, where to fetch it, and a provider’s catalogue. Source: LCP §2.5⁠ (opens in a new tab)
`returns`	Integrated	The address of a returns or claims process. Source: LCP §2.5⁠ (opens in a new tab)
`contact`	Integrated	Legal and technical contacts. Source: LCP §2.5⁠ (opens in a new tab)
`api`	Integrated	The entry point of a legal context API: record management, verification, dispute filing. Source: LCP §2.5⁠ (opens in a new tab)

The optional fields are an index of what the terms document says, so an agent can filter and apply policy without parsing prose. They are not terms: where a field and the document differ, the document controls. Source: LCP §2.5⁠ (opens in a new tab)

The data

Read from the published packages when the site was built; nothing here is typed by hand.

The standard’s own full example

level-4-full.json

{
  "terms": "https://example.com/terms/v3.json",
  "termsFormat": "json",
  "atrHash": "0x7f83b1657ff1fc53b92dc18148a1d65dfc2d4b1fa3d677284addd200126d9069",
  "acceptanceRequired": true,
  "disputeResolution": {
    "method": "Dispute Resolution Service Rules",
    "jurisdiction": "New York, USA",
    "contact": "disputes@example.com",
    "clauseId": "sha256:0xc2eb26d28ff4e229ff35917bd53339d82c1b30ec69435572a8872a4d7609c1dd",
    "source": "https://adr.example.org/clauses/dispute-resolution-service-rules",
    "catalog": "https://adr.example.org/.well-known/dispute-services.json"
  },
  "returns": "https://example.com/api/returns",
  "contact": {
    "legal": "legal@example.com",
    "technical": "api-support@example.com"
  },
  "api": "https://api.example.com/legal-context/v1"
}

The code

Compiled against the published packages when the site is built.

An agent reads a service’s legal front door

src/snippets/discovery.ts

// An agent, before it transacts: read a service's legal front door and the terms it points to.
import { isRefusal } from '@integraledger/lcp';
import { parse, WELL_KNOWN_PATH } from '@integraledger/lcp/discovery';

export async function legalContext(origin: string) {
  const response = await fetch(new URL(WELL_KNOWN_PATH, origin));
  const read = parse(new Uint8Array(await response.arrayBuffer()));
  if (isRefusal(read)) return read;
  return read.document; // terms, and at higher levels atrHash, acceptanceRequired, disputeResolution…
}

Check it yourself

Fetch https://<service>/.well-known/legal-context.json and read terms: the address of the document an agent must inspect. Source: LCP §2.1⁠ (opens in a new tab)

We are not a party you have to trust.

YouThe ATR

Recompute and compare

The payment

Integra: not on the path

Verification does not route through Integra. Anyone holding the ATR checks it themselves — offline, from the bytes and the chain, without our permission or participation.

Integra orchestrates. It never broadcasts a transaction and never takes custody of funds. Your key stays yours, and the gate only ever declines to reach it.

Integra orchestrates. It never broadcasts a transaction and never takes custody of funds. Settlement stays entirely on your rail.

The standard: The Legal Context Protocol (LCP) is co-stewarded by Integra and the AAA-ICDR.
The packages: Published under the Apache-2.0 licence, for anyone to use. Source: @integraledger/lcp README⁠ (opens in a new tab) · Source: @integraledger/terms README⁠ (opens in a new tab) · Source: @integraledger/agentic-connectors README⁠ (opens in a new tab)
Levels of Trust: Levels of Trust

@integraledger/lcp README⁠ (opens in a new tab) · @integraledger/terms README⁠ (opens in a new tab) · @integraledger/agentic-connectors README⁠ (opens in a new tab)

Exhibit The packages and their test vectors Exhibit The four Levels of Trust

Exhibit The packages and their test vectors

The standard

Every package is published under the Apache-2.0 licence on npm: @integraledger/lcp, @integraledger/terms, @integraledger/terms-mcp, @integraledger/agentic-connectors and @integraledger/profile-facilitator; the gate is also on PyPI as integraledger-terms. The hosted appliance speaks the seller door’s contract, an OpenAPI 3.1 document in @integraledger/agentic-connectors. Source: @integraledger/lcp README⁠ (opens in a new tab) · Source: @integraledger/terms README⁠ (opens in a new tab) · Source: @integraledger/agentic-connectors README⁠ (opens in a new tab)

The data

Read from the published packages when the site was built; nothing here is typed by hand.

The seller door’s issue, from the contract’s published vector

request

POST /issue

{
  "mintRequestId": "chk_7Q2:v1",
  "resource": "quote",
  "lifetimeSeconds": 60,
  "offers": [
    {
      "pairing": "x402/exact/eip155/eip3009",
      "option": {
        "scheme": "exact",
        "network": "eip155:84532",
        "amount": "10000",
        "asset": "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
        "payTo": "0x209693Bc6afc0C5328bA36FaF03C514EF312287C",
        "maxTimeoutSeconds": 60,
        "extra": {
          "name": "USDC",
          "version": "2"
        }
      }
    }
  ],
  "request": {
    "method": "GET",
    "path": "/v1/report",
    "query": "",
    "bodyDigest": "0xe3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
  },
  "content": [
    {
      "slot": "terms",
      "bytes": "IlBheSAxMDAwMCBiYXNlIHVuaXRzIG9mIFVTREMgZm9yIG9uZSByZXBvcnQuIg=="
    }
  ]
}

response

{
  "atrHash": "0x3c2394624c8c9a61ebaf7d8750a6f9ac21bf73e6369b7c0b64c83e34509cc3d3",
  "link": "https://atr.seller.example/UW9VslJ1ntPf-n2oOmLDWw",
  "expiresAt": "2026-09-21T14:14:20.000Z",
  "mintRequestId": "chk_7Q2:v1",
  "carriers": {
    "lcp": "lcp:sha256:0x3c2394624c8c9a61ebaf7d8750a6f9ac21bf73e6369b7c0b64c83e34509cc3d3",
    "legalContext": {
      "type": "sha256",
      "value": "0x3c2394624c8c9a61ebaf7d8750a6f9ac21bf73e6369b7c0b64c83e34509cc3d3",
      "legalContextUrl": "https://atr.seller.example/UW9VslJ1ntPf-n2oOmLDWw"
    },
    "legal_context": {
      "type": "sha256",
      "value": "0x3c2394624c8c9a61ebaf7d8750a6f9ac21bf73e6369b7c0b64c83e34509cc3d3",
      "legal_context_url": "https://atr.seller.example/UW9VslJ1ntPf-n2oOmLDWw"
    }
  },
  "pairings": [
    {
      "pairing": "x402/exact/eip155/eip3009",
      "pattern": {
        "pattern": "native-field",
        "canonical": false,
        "profile": "x402/exact/eip155/eip3009",
        "buyerSigns": true,
        "onChain": true,
        "zeroPartyRecoverable": true,
        "forwardIndexable": true,
        "publicProof": true,
        "proves": "The payer signed an EIP-3009 transfer authorization whose nonce is this ATR's hash. The token contract verified that signature when it executed the transfer, and the hash is on chain as the nonce topic of its AuthorizationUsed event in the settlement transaction. This does not show that amount, payee, asset or timing match the ATR's content."
      }
    }
  ]
}

Check it yourself

Run the packages’ test vectors against your own implementation. They fix the ATR’s exact bytes and hash, each refusal, and for each pairing what the payer signs and the ATR hash read back. Source: @integraledger/lcp: vectors and conformance⁠ (opens in a new tab)

Exhibit The four Levels of Trust

The standard

Each level adds members to the one discovery document: Level 1, terms; Level 2, atrHash; Level 3, acceptanceRequired; Level 4, disputeResolution, returns, contact and api. Source: LCP §3⁠ (opens in a new tab) · Source: LCP §2.4⁠ (opens in a new tab) · Source: LCP §2.5⁠ (opens in a new tab)

The data

Read from the published packages when the site was built; nothing here is typed by hand.

Level 1, the standard’s minimal example

level-1-minimal.json

{
  "terms": "https://example.com/terms/v3.md"
}

Level 2, the standard’s provable example

level-2-provable.json

{
  "terms": "https://example.com/terms/v3.md",
  "atrHash": "0x7f83b1657ff1fc53b92dc18148a1d65dfc2d4b1fa3d677284addd200126d9069"
}

Level 3, the standard’s signed example

level-3-signed.json

{
  "terms": "https://example.com/terms/v3.md",
  "atrHash": "0x7f83b1657ff1fc53b92dc18148a1d65dfc2d4b1fa3d677284addd200126d9069",
  "acceptanceRequired": true
}

Talk to us about proving what you buy and sell.

We are at Money20/20 USA, October 18–21, at The Venetian in Las Vegas. Talk to us there.

The hosted appliance is free on test networks, with test-network USDC.

Talk to us

Every kind of commerce runs on agreement.

Are you buying or selling?

Your agent just bought something. Do you know what you agreed to buy? Can you prove it?

Your agent accepted USDC using x402. Can you prove the terms and conditions for what you sold?

The payment is priced. The consequence is not.

A whole new way of doing business: machine to machine, agent to agent, automated and global.

Let agents transact with sellers nobody vetted

Refuse a clause category, everywhere, at once

Answer to a third party

Sell to an agent that has never met you

Offer different terms to different buyers

Resolve a disagreement from the ATR

Based on an open standard, and you add it to the software you already run.

Where the ATR hash rides

We are not a party you have to trust.

Talk to us about proving what you buy and sell.