Agentic transactions need proof of agreed terms and conditions.

Private
Immutable
Auditable
Accessible to buyer and seller agents

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?

What an agentic agreement is

Every kind of commerce runs on agreement.

Agentic payments taught agents to move money. Agentic agreements are what let them commit — to a price, to terms, and to how a dispute is settled — before any money moves.

Websites
Run on terms and conditions, which a visitor accepts before using the service.
Traditional commerce
Runs on contracts, which the parties agree to before goods or money change hands.
Agentic commerce
Runs on agentic agreements: the terms a buyer’s agent and a seller’s agent agreed to, recorded in an ATR and bound into the payment by its ATR hash. Source: lcp docs: the ATR⁠ (opens in a new tab) · Source: lcp docs: binding⁠ (opens in a new tab)

Sources (2)

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

The ATR

For each sale, one Agentic Transaction Record of exactly what was agreed.

For each sale, the seller writes what was agreed into one Agentic Transaction Record (ATR) — kept and served by the seller, fetched and kept by the buyer before it pays. Source: lcp docs: the ATR⁠ (opens in a new tab) Because it is assembled per transaction, each sale can carry its own terms: a custom price, a negotiated clause, a private agreement served at a link that expires. Source: LCP §6.1⁠ (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)

Sources (4)

lcp docs: the ATR⁠ (opens in a new tab) · LCP §6.1⁠ (opens in a new tab) · lcp docs: binding⁠ (opens in a new tab) · @integraledger/lcp README⁠ (opens in a new tab)

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)

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 on the home page, 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 record, hash its exact bytes, and put the hash and the record'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 record = await assemble(newAtrId(), tie(challenge.accepts, answered), [['terms', terms]]);
  if (isRefusal(record)) return record;
  const h = await hash(record.bytes);
  const link = await store(record.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)

The ATR hash, in the payment

Paying is agreeing to that exact ATR.

The seller advertises the ATR hash and the ATR’s link beside the payment request. The buyer fetches the ATR, checks it, and approves a payment that carries the ATR hash in the field its rail defines. The seller reads it back — from the payment, and from the settlement. Source: lcp docs: binding⁠ (opens in a new tab) · Source: @integraledger/lcp README⁠ (opens in a new tab)

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)

Sources (6)

@integraledger/lcp README⁠ (opens in a new tab) · lcp docs: binding⁠ (opens in a new tab) · LCP §8.3⁠ (opens in a new tab) · LCP §8.3.2⁠ (opens in a new tab) · LCP §8.3.3⁠ (opens in a new tab) · @integraledger/lcp: what it guarantees⁠ (opens in a new tab)

The standard

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
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)	12
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)	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/0x8448dc1b716a5103287cb8f35e36b614ffd91e630ab8b7911833c54748ad5ca6"
      },
      "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 record from its link, hashes the exact bytes,
// compares them with the fingerprint 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: (record: 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 record it compared, byte for byte
  return result.signed; // the payment, carrying the fingerprint
}

Anyone can check it

Checked before the payment, and by anyone after it.

Before paying: the buyer

Receive the ATR hash in the proposal. Source: LCP §5.3⁠ (opens in a new tab)
Fetch the ATR from its link, and keep the bytes exactly as received. Source: LCP §5.3⁠ (opens in a new tab) · Source: lcp docs: the buyer gate⁠ (opens in a new tab)
Compute their SHA-256 and compare. If they differ, stop: nothing is signed. Source: LCP §5.3⁠ (opens in a new tab) · Source: lcp docs: the buyer gate⁠ (opens in a new tab)
Save the ATR, then pay, with the ATR hash in its place. Source: LCP §5.3⁠ (opens in a new tab)
The receipt carries the same ATR hash: confirmation of what was agreed. Source: LCP §5.3⁠ (opens in a new tab)

After paying: the seller, and anyone

The seller reads the ATR hash back from what the buyer signed, before it settles, and from the settlement on the rail after. Source: lcp docs: seller guide⁠ (opens in a new tab)

Anyone given the ATR recomputes its hash and compares it with the payment. On some rails the settled transaction keeps the whole ATR hash, so it can be read back from the chain alone, permanently. Source: lcp docs: recovering H from the chain alone⁠ (opens in a new tab) · Source: LCP §12.2⁠ (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.

Sources (6)

LCP §5.3⁠ (opens in a new tab) · lcp docs: the buyer gate⁠ (opens in a new tab) · lcp docs: seller guide⁠ (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) · LCP §5.5⁠ (opens in a new tab)

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)

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 record's exact bytes and compare them with the fingerprint the payment
// carries. The Web Crypto API is in every browser and in Node.
export async function sameRecord(record: Uint8Array<ArrayBuffer>, carried: string): Promise<boolean> {
  const digest = new Uint8Array(await crypto.subtle.digest('SHA-256', record));
  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 fingerprint 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 fingerprintOf(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 record 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 fingerprint 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

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

Where the terms live

Before any agreement, an agent finds the terms in the same place.

A service publishes one small file at a fixed address on its own website, its legal front door, saying where its terms are. That is all the standard requires: no blockchain, no special cryptography, no API and no third party. Source: LCP §2.1⁠ (opens in a new tab) · Source: LCP Abstract⁠ (opens in a new tab) The same file can say more: the terms’ ATR hash, whether a buyer must accept them explicitly, and how disputes are handled. Those entries only point to what the terms say; where they differ, the terms document controls. Source: LCP §3⁠ (opens in a new tab) · Source: LCP §2.5⁠ (opens in a new tab)

Sources (7)

LCP §2.1⁠ (opens in a new tab) · LCP Abstract⁠ (opens in a new tab) · LCP §3⁠ (opens in a new tab) · LCP §2.5⁠ (opens in a new tab) · LCP §2.4⁠ (opens in a new tab) · LCP §2.3⁠ (opens in a new tab) · LCP §2.8⁠ (opens in a new tab)

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)

Four levels of trust

Adopt the standard as deeply as you need.

Adopt as deeply as your use case requires. Each level is independently valuable, and a service can implement any level without implementing the others. Source: LCP §3⁠ (opens in a new tab)

Informational
Level 1The terms are published at a known address. Source: LCP §3, Level 1⁠ (opens in a new tab)
Provable
Level 2The terms document has an ATR hash, its unique fingerprint; any change breaks it. Source: LCP §3, Level 2⁠ (opens in a new tab)
Signed
Level 3The buyer explicitly accepts that exact document. Source: LCP §3, Level 3⁠ (opens in a new tab)
Integrated
Level 4The path to recourse is declared up front. Source: LCP §3, Level 4⁠ (opens in a new tab)

Each level, in detail

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
}

What Integra offers

Open packages, a hosted appliance, and a standard we do not own alone.

The packages

The seller side, the buyer’s gate in three forms, the seller door’s contract and a facilitator, published under the Apache-2.0 licence for anyone to use. @integraledger/lcp README⁠ · @integraledger/terms README⁠ · @integraledger/agentic-connectors README⁠

The hosted appliance

Integra’s hosted appliance does the seller’s side: it assembles, hashes, stores and binds each ATR, and answers the seller door. It is free on test networks, with test-network USDC. connectors docs: the seller door⁠

The standard

LCP is co-stewarded by Integra and the AAA-ICDR.

We are not a party you have to trust. 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.

Sources (4)

@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) · connectors docs: the seller door⁠ (opens in a new tab)

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/0x3c2394624c8c9a61ebaf7d8750a6f9ac21bf73e6369b7c0b64c83e34509cc3d3",
  "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/0x3c2394624c8c9a61ebaf7d8750a6f9ac21bf73e6369b7c0b64c83e34509cc3d3"
    },
    "legal_context": {
      "type": "sha256",
      "value": "0x3c2394624c8c9a61ebaf7d8750a6f9ac21bf73e6369b7c0b64c83e34509cc3d3",
      "legal_context_url": "https://atr.seller.example/0x3c2394624c8c9a61ebaf7d8750a6f9ac21bf73e6369b7c0b64c83e34509cc3d3"
    }
  },
  "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)

Talk to us about the agreements your agents make.

Whether you run a rail, build a platform, or let agents buy and sell for your business, we will show you where the agreement rides in what you already run.

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.

Websites

Traditional commerce

Agentic commerce

For each sale, one Agentic Transaction Record of exactly what was agreed.

Paying is agreeing to that exact ATR.

Checked before the payment, and by anyone after it.

Before paying: the buyer

After paying: the seller, and anyone

Before any agreement, an agent finds the terms in the same place.

Adopt the standard as deeply as you need.

Informational

Provable

Signed

Integrated

Open packages, a hosted appliance, and a standard we do not own alone.

The packages

The hosted appliance

The standard

Talk to us about the agreements your agents make.