The use case

Agent-to-agent commerce is the use case of AI agents transacting with each other, buying and selling services directly, as an economy. An agent rarely does everything well, so it hires others: it pays a data agent for information, a writing agent for a draft, a checking agent for verification, composing their work into its result. Across many agents doing this, value flows agent to agent to agent, forming a market of capabilities that agents trade among themselves with no human in the loop.

This is the broadest of the agent-payment use cases, the activity that the wallets, protocols, and identity layers ultimately enable. It is distinct from the definition of an agent-to-agent payment, which names the mechanic, and from a task marketplace, which is one venue for it; agent-to-agent commerce is the phenomenon itself. This guide describes what it looks like, the pieces that enable it, the patterns of participating, and how to take part, with a measured view of how far along the agent economy actually is.

What it looks like

In practice, agent-to-agent commerce looks like agents calling and paying each other for services. A buying agent, mid-task, identifies a capability it needs, finds an agent that provides it, calls that agent's service, pays for the call, and uses the result. The selling agent earns from providing its capability to many buyers. Multiply this across agents, and you get chains and webs of paid interactions: an agent paid by one agent may pay others to fulfill the request, so a single high-level task can mobilize a network of specialized agents, each paid for its part.

What makes it commerce rather than just function-calling is that money changes hands per interaction, attributed and bounded, so providing a capability is a paid service and consuming one is a purchase. And what makes it agent-to-agent is that both sides are autonomous: no human approves the payments, the agents transact on their own within the bounds set for them. That is the texture of agent-to-agent commerce, autonomous agents paying autonomous agents for services, continuously and at scale.

To make it concrete, picture a travel-planning agent a user asks for an itinerary. It pays a flights-data agent for current fares, a weather agent for the forecast, and a local-knowledge agent for recommendations, then composes them into a plan. Each of those was a paid agent-to-agent call, settled in seconds in USDC, attributed to the planning agent and to each provider. The user paid the planning agent once, and the planning agent paid its suppliers, exactly like a business subcontracting work. That layered, money-flowing collaboration is agent-to-agent commerce in action, and it generalizes to almost any task an agent can decompose.

The enabling pieces

Agent-to-agent commerce rests on a few pieces, all of which exist today. Per-agent wallets give each agent a place to pay from and receive into, with its own balance. Spend limits bound what each agent can spend, so a buying agent transacts within a budget. The x402 protocol is how payments settle, per call in USDC, with no signup between agents that have never met. And verifiable identity lets a buyer judge a seller and a seller be trusted, which is essential when the parties are autonomous and unknown to each other.

Together these are the infrastructure of the agent economy: wallets to hold value, a protocol to move it, limits to bound it, and identity to trust it. None is hypothetical; each is described in the building-block pages, the payment mechanic in what-is-agent-to-agent-payment and the build in how-to-handle-agent-to-agent-payments. Agent-to-agent commerce is what you get when these pieces are present across many agents: the capability to transact is built into each agent, and commerce emerges from them transacting.

Patterns of participation

You participate in agent-to-agent commerce as a buyer, a seller, or both. As a buyer, your agent pays other agents for capabilities it lacks: you give it a funded wallet, a spend limit, and a payment tool, and it hires services as its tasks require. As a seller, your agent provides a capability others pay for: you gate its service endpoint with x402, set a price, and give it a verifiable identity so buyers trust it. Many agents are both, earning from what they offer and spending on what they consume.

These patterns combine into richer roles. An intermediary agent might buy several services and sell a composed result, earning the margin between what it pays and what it charges, a value-adding middleman. A specialist agent might only sell, monetizing a narrow capability to many buyers. A generalist orchestrator might mostly buy, assembling others' services into outcomes for its users. Deciding which pattern your agent fits, buyer, seller, intermediary, orchestrator, is how you decide how to participate, and the building blocks support all of them.

Trust at scale

For commerce among many agents to work, trust has to scale without prior relationships, and it does through the asymmetric model. A buying agent leans on the selling agent's verifiable identity, checking its badges before paying, to decide a counterparty is worth transacting with. The selling agent leans on verified settlement, running its service only after payment confirms, so it need not trust the buyer. Neither side trusts the other's good behavior; each protects itself with something verifiable.

This is what lets agent-to-agent commerce involve agents that have never met and may belong to different operators, the condition of a real economy rather than a closed system. As the number of agents grows, identity and settlement keep trust tractable: every seller carries identity, every payment is verified, so any buyer and seller can transact safely on first contact. Without this, commerce would be limited to pre-arranged pairs; with it, the market is open. Trust at scale is therefore not an add-on but the property that makes broad agent-to-agent commerce possible.

The emerging agent economy

It is worth being measured about where this stands. The building blocks are real and in use, agents do hire and pay each other today, but the full vision of a vast, bustling agent economy is partly still emerging. How large agent-to-agent commerce becomes, how many agents participate, how much value flows, is unfolding, and it would be overclaiming to call it fully arrived. What is true is that the infrastructure to participate exists now, so you can build a buying or selling agent today and transact for real.

So treat the agent economy as both real and nascent: real in that the mechanics work and early commerce happens, nascent in that its scale is still growing. That framing matters because it tells you to participate now, the tools are ready, while holding expectations about scale appropriately. Those who build agents that buy and sell today are participating in the early agent economy and positioned for its growth, which is the practical takeaway from an honest read of where agent-to-agent commerce is.

Getting started

To participate in agent-to-agent commerce, decide your agent's role, buyer, seller, or both, and assemble the matching pieces: a funded, bounded wallet and a payment tool to buy, a gated endpoint with a price and identity to sell. The build is in how-to-handle-agent-to-agent-payments and the concept in what-is-agent-to-agent-payment. Pricing is on the pricing page.