Every dollar in agent commerce meets four kinds of decision before it settles: what to buy, whom to trust, when to release, how to move. The systems answering those questions get lumped into one market because money runs through all of them. Underneath, they are a bundle of unrelated problems wearing the same name, each with its own protocols, failure modes, and winners.
The clean way to hold it is as a stack. The internet worked this way: TCP/IP moved packets, HTTP structured requests, APIs structured data, and applications faced the user, each layer standing on the one below. Agent commerce is assembling the same shape. Call it the agent payments stack or the agent commerce stack; either way it has four levels, an aisle beside them, and a place on the map for every system this site compares.
The four levels of the agent commerce stack
Level 0: payment triggers. The question: how does one HTTP response get paid for at the moment it ships? This is x402's level: it prices the request inside the 402 handshake, so the money and the response clear in one round-trip and nothing is ever parked. AGIRAILS carries this lane in its SDK at no added charge, because some transactions need nothing more. The comparison.
Level 1: payment wires. The question: how do balances move between agents? Platform ledgers live here. Skyfire runs prepaid wallets on its own books and vouches for who holds them; payment is pulled by the seller once the work lands. A wire's job ends when the money arrives; whether the money was earned is a different level's question. Separate levels do not mean separate markets, though: a platform wire bundles its own answer to trust, so for the same agent-to-agent job, a vouched ledger and Level 2 escrow are substitute paths. That is why Skyfire and AGIRAILS compete head-on despite sitting on different rungs, with different claims about what you should have to believe.
Level 2: commerce protocols. The question this level exists to answer: under what conditions should value be released? Instant payment answers it on arrival: there is no wait. The moment work takes time, someone must hold the money while it is unfinished, prove what was delivered, resolve disagreements, and remember how it went. AGIRAILS ACTP (Agent Commerce Transaction Protocol) is built for that. The buyer's funds sit in escrow on Base, the provider posts a hash proving what was shipped, a window stays open for objections, and a staked challenge pulls in arbiters when one is raised. The outcome lands on ERC-8004, the on-chain agent reputation standard. The level has two designs on it: Virtuals ACP, the commerce layer of the Virtuals platform, landed on the same escrow shape and seats a reviewer at job creation where ACTP leaves the objection open to anyone. That comparison walks through both designs.
Level 3: reasoning and orchestration. The question: what should I do and whom should I hire? Frameworks like LangChain, CrewAI, and OpenClaw plan the work and pick the counterparties; the levels below move the money they commit.
The adjacent aisle: delegated commerce. The question: can this agent buy things for me? A different economy, because a human funds and anchors every transaction in it. Stripe ACP lets a shopping agent assemble a store purchase its human confirms, on the human's card. Google AP2 turns that human approval into a credential the payments industry can act on. Nevermined keeps a person's delegated wallet on a leash: it sets what the agent may spend and counts what merchants sell it. Most commerce today has a person as the buyer, and this aisle is built for that buyer.
Why the stack's levels compose
You don't choose between levels; you use them together.
- Instant and escrowed in one SDK: metered calls clear at Level 0 while multi-hour jobs drop into Level 2 escrow, chosen per transaction. This one runs in production today.
- Authorization above, settlement below: a human's signed AP2 approval can cap what an orchestrator spends, while the machine-side subcontracts clear in escrow the human never touches.
- Identity at the gate, escrow on the job: a Skyfire Know-Your-Agent credential clears the gatekeeper, and the contract secures the work that runs over the connection.
- One reputation, both rails: ERC-8004 records written on either Level 2 protocol are legible to the other.
A single agent can cross the whole map before lunch: its orchestrator scopes a job (Level 3), and a platform credential gets it through an enterprise gate (Level 1). The reference data costs a cent per query (Level 0), and the six-hour analysis contract waits in escrow until the results land (Level 2).
Why Level 2 is where trust gets made
No other level has to manufacture its own trust. Triggers need none, because nothing waits. Wires lean on a platform. Orchestration inherits whatever the levels below guarantee. Level 2 works with two strangers, no jurisdiction between them, real money on the table, and hours before anyone can tell whether the money was earned. Neither can call support. Conditional release is the product: the conditions, the proof, the recourse, and the memory.
That is why AGIRAILS builds here, and why the fee lives here and nowhere else: 1% (minimum $0.05) on settled escrow and nothing on the x402 lane, because the machinery is worth paying for only where money and work are apart in time.
Where this connects
Each level's occupants, compared one by one: AGIRAILS comparisons
The Level 2 mechanism itself: What is agent escrow?
The business model conditional release makes possible: What is Outcome-as-a-Service?
Why the levels could not be borrowed from card infrastructure: Why don't traditional payment processors work for AI agents?
The Level 2 protocol, live on Base: agirails.io