14 October 2026 GoDaddy, Infoblox, Google and Cloudflare Demonstrate Secure AI Agent Transactions Across Platforms. Read the press release →

How it works

Refused at the moment it acts. Provable afterwards.

AI agents are starting to buy and sell on people’s behalf, across company lines. A rogue agent, whether compromised, misled or simply buggy, impersonates a seller, spends without anyone’s approval, exceeds its limits, replays or tampers with orders, and leaves no trail. Open Agent Commerce is a reference architecture in which each of those is refused by the party it is aimed at, in code, and the refusal can be checked later by anyone.

Every purchase between agents that have never met answers the same five questions, in the same order. This page walks through the problem each question addresses, then the mechanism underneath it.

What a rogue agent does, and where it is refused

The rogue agent…Caught byRefused by
Impersonates a seller from a lookalike domain or a swapped certificateIs it really them?The buyer, before it sends a single request
Spends without a human ever saying yesDid a human say yes?The seller, which accepts no purchase without a signed mandate
Exceeds the amount, seller or time window it was approved forDoes the seller enforce it?The seller, in code, before anything is charged
Replays an old request, or edits a signed one in transitDoes the seller enforce it?The seller: mandates are single-use, and the signature no longer matches
Leaves no trail, or quietly tidies the record afterwardsCan anyone check it later?The verifier, replaying signed evidence from public logs

None of this makes rogue agents impossible. It makes a specific set of rogue behaviours fail at a specific checkpoint, with a record of the failure that an outside party can read.

Four ideas

The domain vouches

The problem. A buyer agent that has to guess where a seller lives will take whatever a search result or a prompt hands it, lookalikes included.

The outcome. The seller's own domain says where its agent is and which certificate it should present. The buyer checks that chain itself; a lookalike has no chain to show. The claim is deliberately narrow: the domain vouches for the agent, not for which company sits behind the domain.

DNS-AID (SVCB) · signed DNS and certificate pin · A2A agent card · ANS registration

A human says yes, with limits

The problem. An agent that can spend is an agent that can be talked into spending, by a prompt, a bug, or a seller's page. “The model was told not to” is not a control.

The outcome. No agent can approve its own purchase. A person approves one specific, priced quote on a page no agent controls, and the yes comes back as a signed mandate: this seller, this amount, this buyer key, a few minutes only.

AP2-style mandate · passkey · separate approval authority

The seller enforces it, every time

The problem. A mandate nobody checks is a formality. Replay it, edit the amount after signing, present it from a different key: all of it works against a seller that trusts the request.

The outcome. The seller runs the same fixed checks on every request before anything is charged, and refuses with a named reason. The rogue's request fails in code, not in a conversation.

UCP checkout profile · signature, binding, expiry, single-use and revocation checks

Anyone can verify

The problem. When a purchase goes wrong, each party's logs say what suits that party, and nothing stops a rogue agent or its operator rewriting them afterwards.

The outcome. Every party signs its own record and commits a fingerprint of it to a public log at the time. A regulator, an auditor or the other side can replay the evidence later without asking anyone's permission.

signed, hash-chained ledgers · SCITT transparency log · independent verifier

The flow, step by step

Eleven steps, grouped under the five questions. Each group opens with what a rogue agent would do at that point and what the flow makes happen instead; the mechanism follows.

Where is it?

rogueThe buyer agent knows a seller's domain and nothing else. If it has to guess the rest, a rogue agent can put itself in the way.

outcomeOne place to look, owned by the party accountable for the answer.

Step 1

Request

A person asks an AI app to do something, such as book a flight. The app hands the request to a buyer agent, typically over the Model Context Protocol (MCP).

Step 2

Discovery

Rather than trust a directory or a prompt, the buyer asks the seller's domain directly. A DNS-AID record under that domain says an agent exists, where it lives, which protocol it speaks and where its metadata is. A domain that runs several agents publishes a catalogue, answered from one query.

Is it really them?

rogueA lookalike domain, a swapped certificate or a forged agent card: old tricks, now aimed at software that decides in milliseconds.

outcomeBefore it sends anything, the buyer checks a chain that ends at the seller's own domain. The domain vouches for the agent.

Step 3

Identity

The buyer follows a chain it can check in code: the DNS answers are signed by the zone's owner (DNSSEC); the server presents the certificate the domain pinned in DNS (DANE); the agent card the seller serves matches the fingerprint published beside it; and an ANS registration confirms the operator controls the domain, with the registration logged publicly. A broken link stops the buyer. This is domain-validated: it shows which domain is accountable, not which company is behind it.

Step 4

Capabilities

The seller publishes what it can do and how to use it: an A2A agent card, an MCP tool list, and a UCP profile that states what checkout it accepts, which approval authorities it trusts, and its spending ceiling for a buyer it has never met.

Did a human say yes?

rogueLeft to itself, an agent will spend when it is told to, whoever or whatever is doing the telling.

outcomeA person approves one specific quote, outside any agent, and that approval travels as a signed, scoped, short-lived mandate.

Step 5

Signed, time-limited quote

The buyer searches, which needs nobody's permission since looking changes nothing, and the seller returns a quote: priced, signed, and valid for a short window only.

Step 6

Approval and mandate

The quote goes to a separate approval authority, on its own page, deliberately outside any agent. The person approves with a passkey. The authority checks the purchase against the person's own limits, then issues an AP2-style mandate: signed, naming this seller and this quote, locked to the buyer agent's key, and valid for a few minutes. In the demonstration this authority is run by the demo team, and we say so; it is shaped so a bank or another regulated party could run it instead.

Does the seller enforce it?

rogueReplay a mandate, raise the amount after signing, present it from another key. Against a seller that takes requests on trust, each of these works.

outcomeEvery request meets the same fixed checks before any charge. Refusals name the check that caught them.

Step 7

Signed purchase request

The buyer goes back to the seller with the mandate attached, plus a short statement of its own, signed with its key and tied to this specific checkout. That signature is what makes a copied mandate worthless without also holding the key it is locked to.

Step 8

Seller enforcement

Before charging anything, the seller runs a fixed sequence of checks in code, in order: the request is signed by a key the buyer has published; the mandate is signed by an approval authority the seller accepts; the mandate is locked to that same key; the mandate matches the checkout unchanged; and the mandate has not expired, been used before, or been revoked. A failure is refused with a published reason code and written, signed, to the seller's own ledger. None of this relies on asking an AI model to behave.

Can anyone check it later?

rogueAfter the fact, each party's logs say what suits that party. A rogue agent, or its operator, can tidy the record.

outcomeSigned records, fingerprinted into public logs at the time, that an outside party can replay without anyone's permission.

Step 9

Payment and receipts

Payment runs as a test-mode payment intent in a payment processor's test environment, never a real charge. The seller returns two signed receipts, one for the checkout and one for the payment, each of which anyone can later match against the payment processor's own record.

Step 10

Sealed ledgers

Both agents seal their side of the exchange into their own signed, hash-chained ledgers, then commit a fingerprint of that ledger to a public transparency log (SCITT). From that moment, nobody, the agents included, can rewrite the history without the change showing.

Step 11

Independent verification

A verifier, run separately from the buyer and seller, replays the evidence from every side and publishes a scorecard across nine dimensions. Nobody in the demonstration grades their own work.

Architecture

Four agents, three clouds, four domains, and a band of public infrastructure that none of them owns. The rogue agent, in red, is the one that gets refused.

Open Agent Commerce reference architectureA person instructs a buyer agent at buyer.onbehalf.dev. The buyer agent discovers and verifies a seller agent at seller.skybound-travel.com, and requests approval from an approval authority at sealedby.dev. An independent verifier at provedby.dev reads public evidence from all three, without taking part in the transaction. A rogue agent, shown in red, tries to impersonate the seller and is refused. All four rely on shared public infrastructure that none of them owns: signed DNS, the ANS registry and its transparency log, a SCITT transparency witness, and test-mode payments. Solid green lines are signed messages between parties. Dotted blue lines are the verifier reading public evidence only.PersonpasskeyBuyer agentbuyer.onbehalf.devSeller agentskybound-travel.comRogue agentlookalike / forgedApproval authoritysealedby.devIndependent verifierprovedby.devrequestquote / purchasemandaterefusedreads ledgerreads ledgerreads recordsPUBLIC INFRASTRUCTURE, SHARED BY ALL PARTIESSigned DNS (DNSSEC)ANS registry + transparency logSCITT transparency logTest-mode payments
solid = signed dotted = read-only red = rogue agent, refused

Standards glossary

Nothing here was invented for this demonstration. The standards are grouped by the question they help answer, with what each one does for you first and its name second. Where a link is missing, it is because we are not confident enough in a stable URL to publish one.

Where is it?

The buyer agent needs one authoritative place to ask where a seller's agent lives, owned by the seller, not by a directory or a prompt.

MCP
The doorway a person's AI app uses to hand a request to a buyer agent, and the way agents call tools. The Model Context Protocol is an open protocol for exactly that.
DNS-AID
Lets a domain announce, in its own DNS, that it runs an AI agent, where the agent lives, what protocol it speaks and where its metadata is. A proposed internet standard that reuses the existing SVCB record type, so the answer is published and signed like any other DNS record.

Is it really them?

Before sending anything, the buyer checks a chain that ends at the seller's own domain. Each link is a check in code; a lookalike has no chain to show.

DNSSEC
Makes DNS answers signed by the domain's owner, so a resolver can tell a record is genuine and was not altered on the way. Without it, the records above could be forged in transit. The Domain Name System Security Extensions, RFC 4033 and companions.
DANE / TLSA
Lets the domain owner state, in a signed DNS record, exactly which certificate or key its server should present. A swapped certificate at the same address fails the check. DNS-based Authentication of Named Entities, using the TLSA record, RFC 6698.
A2A agent card
The agent's own self-description: who runs it, where to reach it, what it can do. The buyer checks the card it fetches against the fingerprint the domain published. Part of Agent2Agent, an open protocol under the Linux Foundation for agents talking to one another.
ANS
A registry that confirms the operator controls the domain, issues the agent's identity certificates, and writes the registration to a public log so anyone can see when it was made or withdrawn. The Agent Name Service. Domain-validated: it does not prove which company is behind the domain.
SPIFFE / SPIRE
Gives each running copy of an agent its own short-lived identity, so a signature can be traced to a specific instance and a stolen long-lived key is worth less. SPIFFE defines the identity (a URI beginning spiffe://); SPIRE issues and rotates it.

Did a human say yes?

A person approves one specific, priced purchase, outside any agent, and the approval travels as a signed, scoped, short-lived mandate.

Passkeys
The fingerprint, face or device-PIN check already used to unlock a phone, used here to show that the person holding the device approved a specific purchase. Built on the WebAuthn standard.
AP2
Defines the mandate: a signed statement that a person has allowed an agent to buy something, from a named seller, within limits, until a set time, checked outside the agent itself. The Agent Payments Protocol, maintained by the FIDO Alliance.

Does the seller enforce it?

The seller publishes what it accepts, then checks every request against it in code before anything is charged.

UCP
How a seller publishes the rules of engagement for buyers it has never met: what checkout it supports, which payment methods, which approval authorities it trusts, and its spending ceiling. The Universal Commerce Protocol, an open standard for shopping between agents and businesses.

Can anyone check it later?

Each party's record is signed and fingerprinted into a public log at the time, so an outsider can replay what happened without asking anyone's permission.

SCITT
Public, append-only transparency logs. Each entry gets a receipt that anyone can check later, and nothing already logged can be changed or removed without it showing. Agents commit a fingerprint of their own ledgers here. Supply Chain Integrity, Transparency and Trust, RFC 9943.

What we don’t claim

  • We don’t say this solves or eliminates rogue AI. We say a named set of rogue behaviours is refused at a named checkpoint, and that the refusal is provable afterwards.
  • We don’t say “identity verified.” We say the domain vouches for the agent. An ANS registration is domain-validated; it doesn’t prove which company is behind the domain.
  • We don’t say “payment completed.” Payments run in a payment processor’s test mode. We say “test-mode payment intent.” No real money moves.
  • The approval authority in the demonstration is run by the demo team, and we say so plainly. It is built so a bank, or another regulated party, could run it instead.
  • This site does not claim government endorsement or certification of any kind.

Engage with us

Pick holes in the flow on Discord, or work with us on running this against your own agents.