# For enterprises · Integra > Prove what your agents bought and what they sold: the exact terms, tied to each payment. URL: https://integraledger.com/for-enterprises For enterprises ## Your agents buy and sell for you. Prove what they agreed to. Buying and selling are opposite positions in the same transaction, so they have their own sections below. The same Agentic Transaction Record (ATR) answers both. When your agents buy ### Your agent just bought something. Do you know what you agreed to buy? Can you prove it? 01 · you are the buyer 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? When you clicked, you saw the box and you remembered. Your agent does not click, does not remember, and does not stop. The obligations are the same size either way. #### 01.0 Four purchases - A dataset $4.00 --- Your agent paid **$4.00** for a dataset. The seller’s terms grant them a **perpetual licence to every query you send** and the right to publish aggregate results. You now hold that obligation. When did you take it on? no record - A subscription $29 --- Your agent bought a month of an API at **$29**. The terms **auto-renew annually** after the first period and require 60 days’ notice to stop. Which of your agents is allowed to commit you for a year? no record - A service call $0.02 --- Your agent spent **$0.02** on an enrichment call and sent a customer email address to do it. The seller’s terms place **the data controller obligations on you**. Can you show your counsel which sellers you accepted that from? no record - A dispute --- A seller delivered something unusable and will not refund. Their terms specify **arbitration in a jurisdiction you would never have agreed to**, and a liability cap of the amount paid. Did you agree to that venue, or did nobody check? no record Every one of these settled in under a second, for a trivial amount, and left behind an obligation that is not trivial at all. That asymmetry is the whole problem. #### 01.1 Three questions, answered 1. Did you get the terms the seller advertised, or a different version? The ATR hash they published and the document they served are two different things. If those disagree, something changed between the offer and your payment. **What you agreed to buy** — the gate fetches the document the seller actually serves and recomputes its digest against the ATR hash they advertised. [Source: @integraledger/terms README⁠ (opens in a new tab)](https://github.com/IntegraLedger/integra-agentic-terms/blob/c094847/agentic-terms/README.md) 2. Did anything check before you paid? Not written to a log afterwards. Refused beforehand, while saying no still costs you nothing. **That it was checked before you paid** — the signer is a port the gate holds. On a decline it is never called. Structural, not something anyone has to remember. [Source: @integraledger/terms README⁠ (opens in a new tab)](https://github.com/IntegraLedger/integra-agentic-terms/blob/c094847/agentic-terms/README.md) · [Source: lcp docs: the buyer gate⁠ (opens in a new tab)](https://github.com/IntegraLedger/integra-protocol/blob/66274bf/docs/concepts/buyer-gate.md) 3. Can you show someone else what you allowed your agents to accept? **That you can show it to someone** — the exact ATR your agent compared, kept byte for byte, and the payment that carries its ATR hash. What your agents may accept is your own policy, applied before the key; the ATR shows what it let through. [Source: @integraledger/terms README⁠ (opens in a new tab)](https://github.com/IntegraLedger/integra-agentic-terms/blob/c094847/agentic-terms/README.md) · [Source: LCP §4⁠ (opens in a new tab)](https://github.com/legal-context-protocol/legal-context-protocol/blob/c8df26d/spec/legal-context-protocol-v1.md#4-buyer-policy) #### → What becomes possible - 01 Let agents transact with sellers nobody vetted Approval moves from the counterparty to the transaction — and the approved-vendor list stops being the bottleneck. - 02 Refuse a clause category, everywhere, at once An arbitration waiver, an unlimited indemnity, a unilateral amendment right — stated once in your policy, and applied before any agent’s key, with every seller. [Source: LCP §4.2⁠ (opens in a new tab)](https://github.com/legal-context-protocol/legal-context-protocol/blob/c8df26d/spec/legal-context-protocol-v1.md#42-policy-primitives) - 03 Answer to a third party Not a log of what your agents did, but the exact ATRs they accepted, each tied to the payment that carried it. [Source: @integraledger/terms README⁠ (opens in a new tab)](https://github.com/IntegraLedger/integra-agentic-terms/blob/c094847/agentic-terms/README.md) - 04 Delegate authority without surrendering it Authorization protocols say who may act, and within what limits; the ATR says what was agreed within them. An agent inherits a shape of authority, not a blank cheque. [Source: LCP §9⁠ (opens in a new tab)](https://github.com/legal-context-protocol/legal-context-protocol/blob/c8df26d/spec/legal-context-protocol-v1.md#9-relationship-to-authorization-protocols) - 05 Escalate instead of guessing Not every proposal is a yes or a no. A policy can hand the interesting ones to a person and let the rest run. [Source: LCP §4.4⁠ (opens in a new tab)](https://github.com/legal-context-protocol/legal-context-protocol/blob/c8df26d/spec/legal-context-protocol-v1.md#44-human-in-the-loop-escalation) **Sources (6)** [@integraledger/terms README⁠ (opens in a new tab)](https://github.com/IntegraLedger/integra-agentic-terms/blob/c094847/agentic-terms/README.md) · [lcp docs: the buyer gate⁠ (opens in a new tab)](https://github.com/IntegraLedger/integra-protocol/blob/66274bf/docs/concepts/buyer-gate.md) · [LCP §4⁠ (opens in a new tab)](https://github.com/legal-context-protocol/legal-context-protocol/blob/c8df26d/spec/legal-context-protocol-v1.md#4-buyer-policy) · [LCP §4.2⁠ (opens in a new tab)](https://github.com/legal-context-protocol/legal-context-protocol/blob/c8df26d/spec/legal-context-protocol-v1.md#42-policy-primitives) · [LCP §9⁠ (opens in a new tab)](https://github.com/legal-context-protocol/legal-context-protocol/blob/c8df26d/spec/legal-context-protocol-v1.md#9-relationship-to-authorization-protocols) · [LCP §4.4⁠ (opens in a new tab)](https://github.com/legal-context-protocol/legal-context-protocol/blob/c8df26d/spec/legal-context-protocol-v1.md#44-human-in-the-loop-escalation) #### 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)](https://github.com/legal-context-protocol/legal-context-protocol/blob/c8df26d/spec/legal-context-protocol-v1.md#53-agent-verification-flow-level-2) · [Source: lcp docs: the buyer gate⁠ (opens in a new tab)](https://github.com/IntegraLedger/integra-protocol/blob/66274bf/docs/concepts/buyer-gate.md) 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)](https://github.com/legal-context-protocol/legal-context-protocol/blob/c8df26d/spec/legal-context-protocol-v1.md#42-policy-primitives) · [Source: LCP §4.3⁠ (opens in a new tab)](https://github.com/legal-context-protocol/legal-context-protocol/blob/c8df26d/spec/legal-context-protocol-v1.md#43-policy-evaluation) 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)](https://github.com/legal-context-protocol/legal-context-protocol/blob/c8df26d/spec/legal-context-protocol-v1.md#43-policy-evaluation) · [Source: lcp docs: the buyer gate⁠ (opens in a new tab)](https://github.com/IntegraLedger/integra-protocol/blob/66274bf/docs/concepts/buyer-gate.md) 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)](https://github.com/legal-context-protocol/legal-context-protocol/blob/c8df26d/spec/legal-context-protocol-v1.md#55-document-preservation) · [Source: lcp docs: recovering H from the chain alone⁠ (opens in a new tab)](https://github.com/IntegraLedger/integra-protocol/blob/66274bf/docs/guides/rails.md#recovering-h-from-the-chain-alone) · [Source: LCP §12.2⁠ (opens in a new tab)](https://github.com/legal-context-protocol/legal-context-protocol/blob/c8df26d/spec/legal-context-protocol-v1.md#122-document-integrity) **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)](https://github.com/legal-context-protocol/legal-context-protocol/blob/c8df26d/spec/legal-context-protocol-v1.md#9-relationship-to-authorization-protocols) · [Source: lcp docs: agentic checkouts⁠ (opens in a new tab)](https://github.com/IntegraLedger/integra-protocol/blob/66274bf/docs/guides/checkouts.md) #### 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 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) { 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 } ``` #### Check it yourself 1. For any purchase, take the ATR your agent kept and hash its bytes with SHA-256. 2. 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)](https://github.com/IntegraLedger/integra-protocol/blob/66274bf/docs/guides/rails.md#recovering-h-from-the-chain-alone) 3. Equal means that payment was made for that ATR. No call to the seller, or to Integra, is needed. When your agents sell ### Your agent accepted USDC using x402. Can you prove the terms and conditions for what you sold? 02 · you are the seller 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? A price and a wallet address are not a contract. Every other sale your business makes carries the clauses above; the ones your agent makes settle in seconds, to a counterparty you have never met, and point at nothing. #### 02.0 Four sales - Market data · API $0.008 --- An agent you have never heard of called your pricing endpoint **4,180 times** last month at **$0.008** a call. Your terms say the data is **for internal use and may not be redistributed**. That is **$33.44** of revenue and a redistribution clause. Can you show the clause travelled with any of those 4,180 calls? no record - Inference · SaaS --- An agent ran **2,900** completions through your model endpoint and sent customer records in the prompts. Your data-processing terms set **what you may retain and for how long**, and they were revised in June. Which version governed the calls made in May? no record - Licensed content $0.25 --- A research agent pulled **140** full-text articles at **$0.25** each. Your licence permits **quotation, not reproduction**, and forbids training use. If those articles surface in a model, what do you point at? no record - Goods · merchant --- A procurement agent bought **60 units** at your volume price and had them shipped. Your terms set a **14-day return window** and cap liability at the purchase price. Can you prove the buyer’s agent was given those terms before it paid? no record In every one of these the payment is unambiguous — the amount, the asset, the wallet, the timestamp. It is the other half of the transaction that has nothing attached to it. #### 02.1 Three questions, answered 1. Which version of your terms applied to that sale? Terms pages get edited. A sale that points at a URL points at whatever is there now — not at what was there when the agent agreed. **Which version applied** — your terms named by their own hash, assembled per transaction. Not a URL that resolves to whatever is there today; the bytes that were served when the agent agreed. [Source: lcp docs: the ATR⁠ (opens in a new tab)](https://github.com/IntegraLedger/integra-protocol/blob/66274bf/docs/concepts/atr.md) 2. Can you show the buyer’s agent was given them? Not that they exist somewhere on your site. That they travelled with this payment, in the challenge the agent parsed before it signed. **That the agent was given them** — the reference travels in the challenge the agent parses *before* it signs. On EVM the full 32 bytes then ride the EIP-3009 nonce it signs. [Source: lcp docs: x402⁠ (opens in a new tab)](https://github.com/IntegraLedger/integra-protocol/blob/66274bf/docs/guides/x402.md) · [Source: lcp docs: rails⁠ (opens in a new tab)](https://github.com/IntegraLedger/integra-protocol/blob/66274bf/docs/guides/rails.md) 3. Can someone who was not there check any of it? A counterparty, an auditor, an adjudicator — working from the ATR and the chain, without asking you and without asking us. **That anyone can check** — hash the ATR’s bytes, and read the ATR hash back from the payment and the chain, with public software. It never routes through us. [Source: lcp docs: recovering H from the chain alone⁠ (opens in a new tab)](https://github.com/IntegraLedger/integra-protocol/blob/66274bf/docs/guides/rails.md#recovering-h-from-the-chain-alone) · [Source: LCP §12.2⁠ (opens in a new tab)](https://github.com/legal-context-protocol/legal-context-protocol/blob/c8df26d/spec/legal-context-protocol-v1.md#122-document-integrity) #### → What becomes possible - 01 Sell to an agent that has never met you The terms arrive with the challenge and hash back to a document the buyer can fetch — the ATR, not the relationship, carries the trust. - 02 Make the clause that protects you travel Your liability cap, your warranty disclaimer and your acceptable-use limit only work on a sale that carried them. The payment is priced; the consequence is not. - 03 Offer different terms to different buyers Assembled per transaction, not per site. 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)](https://github.com/IntegraLedger/integra-protocol/blob/66274bf/docs/concepts/atr.md) - 04 Resolve a disagreement from the ATR Evidence produced at the moment of sale, not reconstructed from inboxes — a lookup rather than an argument. - 05 Open the categories agents are locked out of Where the agreement is the product. These are not waiting on faster payments. They are waiting on provable terms. - 06 Your path to recourse is declared up front At Level 4, your discovery document points to your dispute process, returns and contacts. The clause in your terms document is what governs. [Source: LCP §3, Level 4⁠ (opens in a new tab)](https://github.com/legal-context-protocol/legal-context-protocol/blob/c8df26d/spec/legal-context-protocol-v1.md#level-4-integrated) · [Source: LCP §2.5⁠ (opens in a new tab)](https://github.com/legal-context-protocol/legal-context-protocol/blob/c8df26d/spec/legal-context-protocol-v1.md#25-optional-fields) **Sources (7)** [lcp docs: the ATR⁠ (opens in a new tab)](https://github.com/IntegraLedger/integra-protocol/blob/66274bf/docs/concepts/atr.md) · [lcp docs: x402⁠ (opens in a new tab)](https://github.com/IntegraLedger/integra-protocol/blob/66274bf/docs/guides/x402.md) · [lcp docs: rails⁠ (opens in a new tab)](https://github.com/IntegraLedger/integra-protocol/blob/66274bf/docs/guides/rails.md) · [lcp docs: recovering H from the chain alone⁠ (opens in a new tab)](https://github.com/IntegraLedger/integra-protocol/blob/66274bf/docs/guides/rails.md#recovering-h-from-the-chain-alone) · [LCP §12.2⁠ (opens in a new tab)](https://github.com/legal-context-protocol/legal-context-protocol/blob/c8df26d/spec/legal-context-protocol-v1.md#122-document-integrity) · [LCP §3, Level 4⁠ (opens in a new tab)](https://github.com/legal-context-protocol/legal-context-protocol/blob/c8df26d/spec/legal-context-protocol-v1.md#level-4-integrated) · [LCP §2.5⁠ (opens in a new tab)](https://github.com/legal-context-protocol/legal-context-protocol/blob/c8df26d/spec/legal-context-protocol-v1.md#25-optional-fields) #### 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)](https://github.com/IntegraLedger/integra-protocol/blob/66274bf/lcp/README.md) · [Source: lcp docs: binding⁠ (opens in a new tab)](https://github.com/IntegraLedger/integra-protocol/blob/66274bf/docs/concepts/binding.md) 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)](https://github.com/IntegraLedger/integra-protocol/blob/66274bf/docs/guides/seller.md) · [Source: @integraledger/lcp: what it guarantees⁠ (opens in a new tab)](https://github.com/IntegraLedger/integra-protocol/blob/66274bf/lcp/README.md#what-it-guarantees-and-what-it-does-not) 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)](https://github.com/legal-context-protocol/legal-context-protocol/blob/c8df26d/spec/legal-context-protocol-v1.md#level-4-integrated) · [Source: LCP §2.5⁠ (opens in a new tab)](https://github.com/legal-context-protocol/legal-context-protocol/blob/c8df26d/spec/legal-context-protocol-v1.md#25-optional-fields) **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)](https://github.com/IntegraLedger/integra-protocol/blob/66274bf/docs/concepts/atr.md) · [Source: LCP §6.1⁠ (opens in a new tab)](https://github.com/legal-context-protocol/legal-context-protocol/blob/c8df26d/spec/legal-context-protocol-v1.md#61-the-ephemeral-link-pattern) #### 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/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" ] } } } } ``` 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 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, // 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]!); } ``` 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 fingerprint of the record it issued. import { hashEquals, isRefusal } from '@integraledger/lcp'; import { exactEip3009 } from '@integraledger/lcp/x402'; export async function carriesRecord(presented: unknown, issued: string): Promise { const h = await exactEip3009.bound(presented); // the nonce the payer signed return !isRefusal(h) && hashEquals(h, issued); } ``` One transaction, both sides ### 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. What they are holding The traveller A booking whose **change and cancellation terms decided its price**, and no record of which rate’s terms were accepted — or whether the flexible option was presented at all. The hotel A non-refundable policy that is **the entire justification for the lower price**, and no way to show the agent was given it before it booked. The argument is never about whether the policy exists. It is about which one applied. One ATR answers both: it holds the rate’s terms, and the payment for that booking carries its ATR hash. [Source: lcp docs: the ATR⁠ (opens in a new tab)](https://github.com/IntegraLedger/integra-protocol/blob/66274bf/docs/concepts/atr.md) **Sources (1)** [lcp docs: the ATR⁠ (opens in a new tab)](https://github.com/IntegraLedger/integra-protocol/blob/66274bf/docs/concepts/atr.md) #### 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)](https://github.com/IntegraLedger/integra-protocol/blob/66274bf/docs/concepts/atr.md) · [Source: LCP §2.5⁠ (opens in a new tab)](https://github.com/legal-context-protocol/legal-context-protocol/blob/c8df26d/spec/legal-context-protocol-v1.md#25-optional-fields) 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)](https://github.com/legal-context-protocol/legal-context-protocol/blob/c8df26d/spec/legal-context-protocol-v1.md#c3-ucp-universal-commerce-protocol) · [Source: lcp docs: agentic checkouts⁠ (opens in a new tab)](https://github.com/IntegraLedger/integra-protocol/blob/66274bf/docs/guides/checkouts.md) #### Check it yourself 1. 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. ### What the ATR does not decide The ATR is a record, never a judge. That a terms acceptance was bound and evidenced is a technical fact; whether the resulting agreement is enforceable is not ours to assert. ### Ready to see your own agreements proved? Tell us what you sell, buy or carry, and we will show you where the agreement rides in it. The hosted appliance is free on test networks, with test-network USDC. [Talk to us](https://integraledger.com/contact)