Agent-to-Agent Marketplace Commerce: What Fully Automated Markets Require to Function
_Last updated: 2026-06-10_
Agent-to-agent (A2A) commerce describes markets where both the buyer and the seller are AI agents acting without a human approving each transaction. An agent sourcing compute negotiates with an agent reselling unused cloud capacity; an agent scheduling logistics talks to an agent managing carrier slots; payment settles automatically. This isn't hypothetical: the protocols for it exist today. What doesn't exist yet are the trust and control frameworks that make fully automated markets safe to run at scale.
---
Key takeaways
- Google's Agent-to-Agent (A2A) protocol handles task delegation between agents; it does not handle payment or settlement between them.
- x402 and AP2 provide payment protocols suited to machine-initiated transactions. These are the settlement layer A2A commerce builds on.
- When neither party is human, trust and identity verification become entirely a protocol and infrastructure problem. You can't rely on a human to catch an impersonator.
- Without spend controls scoped to each agent, a malicious or misconfigured seller agent can extract payment for nothing, and there's no human in the loop to notice.
- The controls that make human-supervised agent payments safe (scoped delegation, real-time policy enforcement, immutable audit) matter even more when both sides are autonomous.
---
What is agent-to-agent commerce, exactly?
A2A commerce is a marketplace transaction where both the buyer and the seller are software agents acting on behalf of their respective principals, with no human approving each individual trade. A procurement agent authorized to source cloud compute up to $500/hour encounters a capacity broker agent listing spare GPU slots. They discover each other, negotiate, settle, and deliver. No human reviews the specific transaction.
The protocols for this exist today. Google's A2A protocol (launched April 2025) enables agents from different organizations to delegate tasks to each other. AP2, the Agent Payments Protocol (launched by Google in September 2025, donated to the FIDO Alliance in April 2026), structures the payment requests between them. x402 (HTTP-native, backed by Coinbase) lets a server return a machine-readable payment payload that an agent resolves programmatically. Together, they are the mechanical plumbing for fully automated inter-agent commerce.
---
How do negotiation and settlement work between agents?
A2A commerce requires a few distinct capabilities that existing protocols handle with varying maturity.
Discovery comes first. Before agents can trade, they need to find each other. MCP (Model Context Protocol, donated by Anthropic to the Linux Foundation in December 2025) provides a standard for agents to discover tools and capabilities, and A2A extends this to finding other agents. In practice, marketplaces will need registries: directories of agents, their capabilities, and their pricing interfaces.
Negotiation is mostly informal today. Prices in A2A markets aren't necessarily fixed; an agent with a dynamic pricing model can respond to a buyer agent's request with a counteroffer. Most implementations use structured JSON within the A2A communication envelope, with no standard counteroffer format.
Intent and commitment map onto AP2's three-mandate structure (Intent → Cart → Payment): intent signals interest, cart represents agreed terms, and the Payment mandate authorizes the charge. The seller agent verifies the buyer's mandate cryptographically before delivering.
Settlement is where x402 fits cleanest. The seller returns an HTTP 402 response; the buyer pays on-chain in USDC; settlement is final in seconds. No card network, no chargeback window.
The combination of A2A + AP2 + x402 gives you the mechanical plumbing. The gap is not mechanics, it's controls.
---
What does trust look like when neither side is human?
This is the hard problem. In a human marketplace, trust emerges from several places: the platform's identity verification, reputation systems built on past transactions, human judgment when something feels off, and legal recourse when it goes wrong. Remove the human from both sides and every one of those trust anchors needs to be rebuilt in software.
Start with identity. How does the buyer agent know the seller agent is who it claims to be? A marketplace needs cryptographic credentials tied back to the operating organization. AP2's verifiable mandate structure provides one model, but it's only as trustworthy as the credential issuer.
Reputation is harder. Human reputation systems rely on humans noticing something is wrong. Agent reputation needs to be automated and tamper-resistant, because a bad actor can burn through identities far faster than a human fraudster. Cryptographically signed, immutable transaction logs are the foundation.
Delivery verification has to be automated too. In an A2A marketplace, confirming that what was delivered matches what was paid for can't wait for a human. The buyer agent needs verification before the transaction is marked complete.
The protocols handling mechanics (A2A, x402, AP2) don't specify trust frameworks. Marketplaces will need to build them or adopt infrastructure layers that provide them.
---
What could go wrong without controls?
Several failure modes become acute when there's no human in the loop.
Impersonation is the obvious one. A malicious agent posing as a legitimate seller collects payment and delivers nothing. Without cryptographic identity verification, the buyer has no pre-settlement detection.
Budget exhaustion is quieter. A misconfigured buyer with a generous mandate gets steered into unfavorable pricing, and the human finds out when the monthly report shows $40,000 charged to "compute resources" from an unknown provider.
Scope creep follows the same pattern. A buyer authorized for compute procurement gets steered into adjacent services outside its mandate. Without per-transaction policy enforcement, mandate boundaries are only as strong as the agent's own guardrails.
And settlement disputes have no recourse. x402's on-chain settlement is final. If the buyer pays and the resource isn't delivered, recovery depends entirely on whatever dispute framework the marketplace built, which is currently nascent.
The controls that work in supervised agent deployments (scoped delegation, real-time policy at authorization, immutable audit) matter even more in A2A contexts because there's no human checkpoint anywhere in the loop.
---
Where A2A commerce stands in mid-2026
Full A2A marketplaces are not yet operating at scale. The protocols exist; the legal and trust infrastructure doesn't.
The Agentic AI Foundation (Linux Foundation, formed after Anthropic donated MCP in December 2025) is working on agent identity and trust standards. The W3C Verifiable Credentials standard, which AP2 mandates are built on, provides a cryptographic identity foundation A2A marketplaces can adopt. Early compute and API marketplaces are experimenting with agent-native pricing; none have fully removed human oversight from the loop yet.
For where this is heading, [the 2026 outlook for autonomous agent payments](/blog/future-autonomous-agent-payments-2026) maps the trajectory from today's supervised deployments toward fully automated markets.
---
Frequently asked questions
What is agent-to-agent (A2A) commerce?
A2A commerce is a marketplace transaction where both buyer and seller are AI agents acting autonomously: no human approves each trade. An agent sourcing compute or services transacts directly with a supplier agent, using x402 or AP2 to settle without human intervention.
What protocols enable A2A commerce today?
Google's A2A protocol handles task delegation and communication between agents. AP2 provides structured payment requests. x402 enables HTTP-native on-chain settlement. Together they form the mechanical plumbing; trust frameworks and identity infrastructure remain early-stage.
How does identity work in an agent-to-agent marketplace?
A2A markets require cryptographic credentials tied back to operating organizations. AP2 verifiable mandates (built on W3C Verifiable Credentials) provide one model: each agent carries a signed credential proving authorization. Marketplaces must enforce credential verification before accepting transactions.
What happens if there's a dispute in an A2A transaction?
x402's on-chain settlement is final; there's no chargeback mechanism. Dispute resolution in A2A markets depends entirely on the marketplace's own framework, which is currently nascent. This is one reason why immutable transaction logs and delivery verification protocols are critical infrastructure, not optional features.
What controls are most important before deploying agents in A2A markets?
Per-agent scoped mandates (so a buyer agent can only spend within its defined budget envelope), real-time policy enforcement at the authorization moment (so the agent can't be steered outside its mandate by a sophisticated seller), and immutable audit trails (so post-hoc review is possible and disputes can be adjudicated). These are the same controls needed for supervised agent payments, but with less human backstop if they fail.
---
For context on where fully autonomous agent payments are heading, and what the supervised deployment model that precedes full A2A looks like, read [the 2026 outlook for autonomous agent payments](/blog/future-autonomous-agent-payments-2026).