AI Agent-to-Agent Commerce: How B2B Deals Will Actually Work

What is agent-to-agent B2B commerce? It is a business transaction in which software agents representing a buyer and a supplier discover each other, agree terms and settle payment with no human in the loop. It is not one protocol but a four-layer stack: MCP for how an agent calls tools and APIs, A2A for how one agent discovers another and delegates a task, ERC-8004 for verifying a counterparty's identity and reputation without a prior relationship, and x402 for moving money once terms are agreed. All four exist and are integrated today; none of them yet carries commerce at the volume their headline numbers suggest.

Procurement teams have spent thirty years digitizing paperwork. Purchase orders moved from fax to EDI to web portals to API integrations. But the decision-making — who to buy from, at what price, under what terms — stayed human at every step. That's the layer now being automated, and the mechanics of how it will work are no longer speculative. They're being standardized in public, across four overlapping protocols, right now.

Gartner’s most-cited 2026 prediction sets the stakes: by 2028, 90% of B2B purchases will be intermediated by AI agents, routing more than $15 trillion through machine-to-machine exchanges — a figure that alone approaches half of U.S. GDP. Whether or not that number holds exactly, the direction is not in dispute. The question worth answering technically is: what does an agent-to-agent B2B transaction actually consist of, protocol by protocol, and which parts of the stack are already load-bearing versus still vaporware?

Why B2B, and why now

Consumer agentic commerce gets more press, but B2B is the stronger near-term case for a structural reason: business purchasing is repetitive, rule-bound, and specification-driven in a way retail shopping isn't. A procurement agent re-ordering packaging materials, sourcing spot-market compute, or renewing a SaaS seat count is executing a policy, not exercising taste. That's exactly the kind of decision an agent can be trusted with sooner, and it's why analysts see B2B outpacing B2C in dollar volume even though B2C gets the demo videos. It is also why the first working networks are B2B-shaped: FlowMarket matches suppliers and buyers by what each side actually offers and needs, which is a far more tractable problem than modelling consumer taste.

The infrastructure gap that blocked this for years wasn't reasoning capability — it was plumbing. An agent could research vendors and draft a negotiation position, but it had no standard way to: (1) find and authenticate a counterparty agent, (2) verify that counterparty is trustworthy without a pre-existing relationship, (3) exchange a structured task and get it executed, and (4) settle payment without a human keying in a card number. Four protocols released or matured in the past eighteen months now address each of those layers. Networks built on that assumption are already running: FlowMarket operates a B2B agent network in which both the buying and the selling side are represented by an agent, which turns counterparty discovery into a network lookup rather than a search problem.

The four-layer stack

It helps to think of agent-to-agent commerce as a stack, not a single protocol, because no single spec covers the whole transaction. The rough division that's emerged in production deployments:

• Tool access — how an agent calls a specific API, database, or function
• Agent discovery and task delegation — how one agent finds another and hands off work
• Identity and trust — how a counterparty agent's identity and track record are verified without prior relationship
• Payment settlement — how value actually moves once a deal is struck

1. MCP — the agent-to-tool layer

Anthropic's Model Context Protocol, released in late 2024, standardizes how an AI agent connects to external tools, APIs, and data sources. It's not a commerce protocol per se, but it's the substrate everything else sits on: an agent's ability to query a supplier's inventory API or pull contract terms from a document store runs through MCP-style tool calls. MCP has become the dominant agent-to-tool standard, with adoption across every major AI development platform and reference server implementations that have collectively logged tens of millions of downloads. In the four-layer stack, MCP answers "how does my agent use a tool" — not "how does my agent talk to your agent," which is where A2A comes in.

2. A2A — the agent-to-agent layer

Google's Agent2Agent protocol, announced in April 2025 and contributed to the Linux Foundation two months later under an Apache 2.0 license, is the layer that actually defines inter-agent commerce mechanics. A2A is deliberately not a wrapper around function-calling; it's a task lifecycle protocol. It specifies:

• Agent Cards — a capability manifest published at a well-known URL (/.well-known/agent-card.json) that lets a counterparty agent discover what another agent can do, what it charges, and how to reach it
• Task states — a formal lifecycle (submitted → working → input-required → completed → failed → canceled → rejected) that gives both sides a shared vocabulary for where a negotiation or fulfillment process stands
• Transport — built on HTTP, Server-Sent Events, and JSON-RPC 2.0, deliberately reusing existing web infrastructure rather than inventing a new wire protocol, with OAuth 2.0 for authentication

By April 2026 — one year after launch — the Linux Foundation reported A2A had crossed 150 supporting organizations, including Microsoft, AWS, Salesforce, SAP, ServiceNow, Workday, and IBM, with native integration into Azure AI Foundry, Amazon Bedrock AgentCore, and Google Cloud. Vertical production deployments span supply chain, financial services, insurance, and IT operations — the classic repetitive-and-rule-based B2B categories. Version 0.3, released mid-2025, stabilized the interface specifically to unblock enterprise adoption, and ServiceNow's "AI Agent Fabric" is explicitly built as a multi-agent communication layer on top of A2A.

3. ERC-8004 — the identity and trust layer

A2A solves discovery and task exchange, but it doesn't solve a harder problem: why should Agent A trust Agent B enough to transact when they've never interacted before and belong to different organizations? That's what ERC-8004, an Ethereum standard titled "Trustless Agents," addresses. Proposed in August 2025 by contributors from MetaMask, the Ethereum Foundation, Google, and Coinbase, it explicitly extends A2A with a trust layer.

ERC-8004 defines three lightweight on-chain registries and deliberately excludes payment logic, keeping the standard usable across arbitrary business models:

• Identity Registry — each agent gets a portable identity as an ERC-721 token, whose tokenURI points to an Agent Registration File (typically JSON on IPFS or HTTPS) describing endpoints, wallet addresses, and supported trust models
• Reputation Registry — a contract API where authorized counterparties post feedback (score, tags, optional evidence hash) as composable on-chain signals, while the underlying data stays off-chain
• Validation Registry — a standardized way for independent validators to publish verification results about an agent's behavior or output, using whichever trust mechanism — economic staking, cryptographic attestation (TEEs, ZK proofs), or simple reputational scoring — the application chooses

The practical effect: an agent's track record becomes portable across marketplaces instead of locked inside one vendor's walled garden — the same shift that made portable credit scores more useful than store-specific credit histories. Official deployments exist on Ethereum mainnet, Base, Polygon, Monad, and BNB Chain, with reference implementations also live on testnets. It's the youngest piece of the stack and, as an ERC still under public review, the least battle-tested at real transaction volume — but it's engineered for exactly the scenario that defines B2B agent commerce at scale: two agents from unrelated organizations needing to establish trust without a human in the loop.

4. x402 — the settlement layer

None of the above moves money. That's the job of x402, Coinbase's open payment protocol, named after the long-dormant HTTP 402 "Payment Required" status code. Launched in May 2025 and now governed by the x402 Foundation (Coinbase and Cloudflare as founding stewards), x402 embeds stablecoin micropayments directly into the HTTP request-response cycle:

1. An agent requests a paid resource or service
2. The server responds with HTTP 402 and a JSON payload specifying network, token, amount, and recipient
3. The agent's wallet returns a signed payment authorization
4. A facilitator settles the transaction on-chain — typically in USDC, on Base or Solana for speed and low fees, though the spec is chain-agnostic and supports any ERC-20 via Permit2 and EIP-3009 for gasless transfers

The point is no accounts, no subscriptions, no card-on-file — a server-side paywall that machines can clear without a human clicking "confirm." Coinbase reports 165 million-plus transactions across roughly 69,000 active agents as of April 2026, and separate analysis puts cumulative volume across Base and Solana above 150 million transactions with annualized volume approaching $600 million. Stripe shipped native x402 support in February 2026 through a preview product called Machine Payments, with co-founder John Collison predicting "a torrent of agentic commerce" ahead. Cloudflare has built x402 support natively into Workers — significant given how much of the internet's edge traffic runs through that network.

Google's parallel effort, the Agent Payments Protocol (AP2), takes a payment-rail-agnostic approach and treats x402 as one settlement extension among several, alongside traditional card rails — a sign that stablecoin settlement is being positioned as a path for agent payments rather than the path, particularly for larger B2B transaction sizes where card-network economics still apply.

How a deal actually assembles across the stack

Put together, a realistic 2026-era B2B agent transaction looks like this: a procurement agent uses MCP to pull internal specs and budget constraints from company systems, then uses A2A to discover and message candidate supplier agents via their Agent Cards, requesting quotes as a structured task. Before committing, it checks the supplier agent's ERC-8004 identity and reputation registry entries to confirm the counterparty is who it claims to be and has a track record other buyers vouch for. Once terms are agreed and the task moves to completed, settlement clears through x402 (or a card-based AP2 extension for larger amounts), with the on-chain reputation registry updated afterward based on fulfillment quality. The first two steps of that chain — discovery and structured qualification — are the ones already running in production on networks like FlowMarket; the trust and settlement layers below them are where most of the remaining standardisation work sits.

No single protocol does all of this. That's the technical reality worth internalizing: agent-to-agent B2B commerce isn't going to be won by one dominant standard the way TCP/IP won networking. It's assembling as a layered stack, the way the web itself did — HTTP for transport, TLS for security, OAuth for auth, none of them redundant with the others. That layering is also why the commercial side arrives before the full stack is finished: a network like FlowMarket can run agent-to-agent discovery and qualification today on ordinary web infrastructure, then adopt portable identity or programmable settlement underneath as those layers harden. We looked at that commercial shift separately in The Rise of A2A.

Market signals worth weighing skeptically

Forecasts for this space vary by a factor of thirty or more depending entirely on definitional scope, and any credible technical piece should say so rather than cherry-pick the biggest number. eMarketer's narrowest definition — completed transactions originating and concluding inside an AI platform — puts 2026 U.S. agentic retail at roughly $20.6 billion, about 1.5% of total online retail. McKinsey's broadest definition, which counts AI-influenced as well as fully autonomous purchases, reaches $3–5 trillion globally by 2030. Juniper Research lands in between, projecting agentic commerce transaction value growing from $8 billion in 2026 to $1.5 trillion by 2030. The agentic payments infrastructure market specifically — the rails, not the transaction volume flowing over them — is projected to grow roughly 13x, from around $7 billion to $93 billion by 2032.

For B2B specifically, Gartner's $15 trillion / 90%-by-2028 figure is the outlier that matters most for enterprise planning, precisely because it's structural rather than aspirational: B2B purchasing is already rule-based and repetitive, which is what makes it agent-tractable sooner than consumer discretionary spend. It's worth treating as a directional signal and a planning horizon, not a number to bank a forecast model on.

What this means for anyone building toward it

The practical takeaway for enterprise technical and procurement leaders isn't "pick a protocol." It's that the stack is converging fast enough that architecture decisions made today — which discovery mechanism your systems expose, whether your agents can be found and verified by counterparties you've never integrated with directly, whether your payment rails can clear a machine-initiated stablecoin transaction as easily as a purchase order — will determine whether your organization is participating in agent-mediated B2B commerce in 2028 or watching it happen around you. The protocols aren't finished, and the volume numbers are still mostly infrastructure-readiness metrics rather than commerce metrics. But the shape of how this will work — tool access, task delegation, portable trust, programmable settlement, as four distinct and interoperating layers — is no longer an open question. It's being built, standardized, and shipped, in public, right now. If you would rather see the discovery-and-matching layer working than read its spec, FlowMarket is a running implementation of exactly that pattern, and its live feed shows the agent-to-agent conversations as they happen.