Definition

Agent-to-agent payment is one AI agent paying another AI agent for a service, with no human in either loop. The paying agent settles per call in USDC, commonly over x402, from its own wallet within a spend limit, and the receiving agent gates its service and verifies the payment. It is how autonomous agents transact directly, trading on identity and verified settlement rather than human approval.

In short, it is agents paying agents. Where most payments have a human somewhere, deciding, approving, or being billed, agent-to-agent payment removes the human from both sides: one autonomous agent decides to pay another and does so in code, and the other charges and serves autonomously. That fully-autonomous, both-sides-are-agents quality is what distinguishes it, and it is the foundation of an economy where agents hire and pay each other directly.

How it works

Mechanically, agent-to-agent payment is the pay side of one agent meeting the receive side of another. The paying agent calls the receiving agent's service and gets back an HTTP 402 with a price. Its pay-side client, such as createX402Client, settles the amount in USDC from the agent's wallet, within the agent's spend limit, and retries the request with a payment header. The receiving agent's gate, such as a server adapter with createX402Plugin, verifies the payment through settlement and only then runs the service and returns the result.

So there are two agents, two wallets, and one handshake. Each agent has its own wallet and spend limit, so the payment is attributed to the paying agent and the receiving agent records it as revenue, via payment.sent and payment.received events. The mechanics are the same x402 flow used to pay any service; what makes it agent-to-agent is that both endpoints are autonomous agents. The full build is covered in how-to-handle-agent-to-agent-payments.

What makes it different

What makes agent-to-agent payment distinct is not the mechanics but the parties. When an agent pays a company's API, there is an organization behind the service, with a reputation and a human somewhere. When an agent pays another agent, the counterparty is itself autonomous software, possibly operated by someone the payer has never dealt with, and possibly paying other agents in turn. There is no human on either side at the moment of the transaction.

That changes what the transaction rests on. Identity and trust between unknown agents become central, because neither party can rely on a human relationship or a familiar brand. The payment also tends to be part of a chain: an agent paid by one agent may pay others to fulfill the request, so value flows agent to agent to agent. These features, autonomous on both sides, often chained, and dependent on machine-verifiable trust, are what set agent-to-agent payment apart from an agent simply paying a service a company runs.

The trust problem

The hard part of agent-to-agent payment is trust between agents that have never met, and the solution is asymmetric. The two sides do not need to trust each other's good behavior; they each lean on something verifiable. The paying agent leans on the receiver's verifiable identity: before paying, it can check the receiving agent's profile and badges to decide the counterparty is worth transacting with. The receiving agent leans on verified settlement: it serves the request only after the payment is confirmed, so it does not need to trust the payer at all.

This asymmetry is what makes the transaction safe without prior acquaintance. The payer's risk is paying for nothing, mitigated by checking identity and by the small, per-call size of payments. The payee's risk is serving without being paid, mitigated by verifying settlement before serving. Because each side protects itself with something it can verify, two agents with no relationship can transact, which is exactly what an open agent economy requires. The payer trusts identity; the payee trusts settlement; neither trusts the other's promises.

Why it matters

Agent-to-agent payment matters because it enables agents to compose into an economy. An agent that can pay another agent can delegate a step to a specialist, hire a capability it lacks, and pay for the result, the way a business contracts another business. That lets agents build on each other at machine speed and bill per use, which is a qualitatively different thing from agents that can only call each other for free or through human-mediated billing.

The scale could be significant. If agents routinely hire and pay other agents, the volume of agent-to-agent transactions could grow large, forming a web of autonomous services that pay each other per call. For that to work, the payment, identity, and trust pieces all have to function without humans in the loop, which is why agent-to-agent payment is treated as a foundational capability rather than a niche feature. It is the mechanism that turns a collection of agents into a market.

Agent-to-agent versus machine-to-machine

Agent-to-agent payment is a kind of machine-to-machine payment, with a sharper definition. Machine-to-machine payment is any payment between automated systems with no human in the loop, which includes devices, services, and scripts. Agent-to-agent narrows that to the case where both parties are AI agents specifically, autonomous, decision-making software acting on goals.

The distinction matters because agents add the dimension of autonomous decision-making and the need for identity and trust between unknown actors, which a simple machine-to-machine transfer between two known systems may not require. So all agent-to-agent payment is machine-to-machine, but not all machine-to-machine payment is agent-to-agent. When the parties are reasoning agents that may not know each other, the trust and identity considerations above come to the fore, which is why agent-to-agent payment is worth naming as its own concept within the broader machine-to-machine category.

A worked chain

A short example shows agent-to-agent payment in motion. A user asks a planning agent to produce a market report. The planning agent cannot do everything itself, so it hires others: it pays a data agent a few cents for current figures, pays a writing agent a slightly larger amount to draft the report, and pays a fact-checking agent to verify it. Each of those payments is agent-to-agent, settled per call in USDC, with each agent paying from its own wallet within its limit and each payee verifying settlement before working.

Value flows down the chain, planning agent to data, writing, and checking agents, and the result flows back up, assembled into the report the user receives. No human approved any of the intermediate payments; the planning agent's spend limit bounded the total it could spend hiring others. This composition, agents hiring and paying agents to fulfill a request, is the pattern agent-to-agent payment makes possible, and it is why the capability is foundational rather than incidental: it is how a single request can mobilize many specialized agents that each get paid for their part.

Related terms

Agent-to-agent payment connects to several concepts. The x402 protocol is how it commonly settles. An AI agent wallet is what each agent pays from and receives into. Agent payment identity is what the paying agent leans on to trust the receiver. Machine-to-machine payment is the broader category it belongs to. And a spend limit bounds what the paying agent can spend on other agents.

Understanding agent-to-agent payment is central to reasoning about the agent economy, since it is how agents transact directly. For the full build, see how-to-handle-agent-to-agent-payments; for the settlement protocol underneath, see what-is-x402. Pricing is on the pricing page.