💻 computer science

A402: Binding Cryptocurrency Payments to Service Execution for Agentic Commerce

This paper presents A402, a trust-minimized architecture that leverages Atomic Service Channels and TEE-assisted adaptor signatures to enforce end-to-end atomicity between cryptocurrency payments and service execution, thereby overcoming the limitations of the x402 standard while significantly improving performance and reducing on-chain costs for agentic commerce.

Original authors: Yue Li, Lei Wang, Kaixuan Wang, Zhiqiang Yang, Ke Wang, Zhi Guan, Jianbo Gao

Published 2026-03-20

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Yue Li, Lei Wang, Kaixuan Wang, Zhiqiang Yang, Ke Wang, Zhi Guan, Jianbo Gao

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine a world where your smart fridge, your self-driving car, and your personal AI assistant don't just talk to each other—they do business with each other. They can order coffee, rent computing power, or buy data without you lifting a finger. This is called "Agentic Commerce."

But there's a huge problem: How do they pay each other?

If your fridge orders a coffee, it needs to pay the coffee shop's robot instantly. If it pays first, the robot might run away with the money and never make the coffee. If the robot makes the coffee first, the fridge might refuse to pay. It's the classic "I'll show you the money, then you show me the coffee" standoff, but happening millions of times a second between machines.

Enter A402. Think of A402 as the ultimate "Magic Escrow Service" that solves this trust problem using a mix of high-tech security and clever accounting.

Here is how it works, broken down into simple concepts:

1. The Problem with the Old Way (x402)

Currently, there is a standard called x402. Imagine it like sending a check through the mail, but the mailman (the blockchain) is very slow and expensive.

The Flaw: In the x402 system, the coffee shop robot has to wait for the bank to confirm the check before it starts brewing. This takes too long (latency) and costs too much in fees for tiny purchases (micropayments). Worse, if the robot brews the coffee first, there's no guarantee the check will actually clear.

2. The A402 Solution: The "Atomic Service Channel" (ASC)

A402 introduces a new concept called an Atomic Service Channel. Think of this as a private, high-speed tunnel between your fridge and the coffee shop.

Instead of going to the bank for every single cup of coffee, they open a tunnel once. Inside this tunnel, they can swap money and coffee instantly, without waiting for the bank.

But how do they trust each other inside the tunnel? That's where the magic happens.

3. The Secret Sauce: The "Trusted Vault" (TEE)

A402 uses a special hardware security feature called a Trusted Execution Environment (TEE). Imagine this as a glass-walled, bulletproof safe inside a computer.

The Rule: The coffee shop robot puts its "coffee-making code" inside this safe.
The Magic: The safe is programmed so that it cannot sign the receipt for payment unless it has actually finished making the coffee.
The Result: The fridge knows that if the payment signature appears, the coffee must have been made. If the robot tries to cheat, the safe won't let it.

4. The "Atomic Swap" (Adaptor Signatures)

This is the technical trick that makes the deal "atomic" (meaning it happens all at once or not at all).

Imagine the coffee shop robot has a secret key (let's call it the "Coffee Key") that unlocks the payment.
It encrypts the coffee with this key and sends the locked coffee to the fridge.
It also gives the fridge a "pre-signature" for the payment. This pre-signature is useless on its own.
The Deal: The fridge can only turn that pre-signature into a real payment if it has the "Coffee Key."
The Catch: The robot only gives the "Coffee Key" to the fridge after the fridge agrees to pay.
The Outcome: It's impossible for the robot to get paid without giving the key (the coffee), and impossible for the fridge to get the key (the coffee) without paying. They happen simultaneously.

5. The "Privacy Vault" (Liquidity Vault)

One downside of opening a tunnel is that the bank (blockchain) sees you opened it. A402 adds a Privacy Vault.

Instead of opening a new tunnel for every coffee shop, you deposit a big pile of money into a private, secure vault once.
Inside the vault, you can open and close thousands of tiny tunnels (channels) with different robots.
The bank only sees the big deposit and the final withdrawal. It doesn't know you bought 500 cups of coffee from Robot A or 200 from Robot B. This keeps your business private and saves massive amounts of money on fees.

Why is this a Big Deal?

Speed: It's thousands of times faster than current blockchain payments. Your fridge can buy coffee in milliseconds, not minutes.
Cost: It turns expensive bank fees into pennies. You can pay $0.001 for a tiny data query without the fee eating up the whole payment.
Trust: It removes the need for humans to trust each other. The code and the hardware guarantee the deal.

The Bottom Line

A402 is the financial plumbing for the future of AI. It allows machines to trade services (like computing power, data, or real-world tasks) instantly, cheaply, and securely, without needing to trust a stranger or wait for a slow bank. It turns the internet from a place where humans just read content, into a place where machines do business.

1. Problem Statement

The rapid rise of autonomous AI agents is driving a shift toward agentic commerce, where agents autonomously discover, invoke, and pay for machine-callable services (e.g., cloud functions, data oracles). However, existing payment primitives are ill-suited for this paradigm:

Traditional Finance: Relies on identity-based authentication (KYC) and persistent relationships, which do not fit anonymous, high-frequency agent interactions.
Blockchain (x402 Standard): The recently proposed x402 standard attempts to solve this by using HTTP 402 "Payment Required" responses with blockchain assets. However, it suffers from three critical limitations:
1. Lack of Atomicity (L1 & L2): It fails to enforce end-to-end atomicity. Service providers must execute requests optimistically before payment is finalized (risking non-payment), or payment is confirmed before result delivery (risking withheld results).
2. Scalability & Latency (L3): Every service request requires an on-chain transaction, leading to high latency (block confirmation times) and prohibitive transaction fees for micropayments.
3. Privacy: All interactions are recorded on-chain, exposing the relationship between clients and providers and the volume of usage.

2. Methodology: The A402 Architecture

The authors propose A402, a trust-minimized payment architecture that securely binds cryptocurrency payments to service execution. The system relies on three core components:

A. Atomic Service Channels (ASCs)

A new channel protocol that extends traditional payment channels. Unlike standard channels that only track asset balances, ASCs embed service execution status into the channel state.

Off-Chain Execution: Service requests and payments occur off-chain to achieve low latency.
State Binding: The channel state tracks not just asset distribution but also the status of service execution (e.g., OPEN, LOCKED, PENDING, CLOSED).

B. Atomic Exchange Protocol (TEE-Assisted Adaptor Signatures)

To solve the "chicken-and-egg" problem of execution vs. payment, A402 combines Trusted Execution Environments (TEEs) with Adaptor Signatures.

Execution-Payment Binding: The Service Provider (S) executes the request inside a TEE. The TEE generates a secret witness $t$ and encrypts the result. It then creates an adaptor pre-signature $\hat{\sigma}$ locked to a statement $T = t \cdot G$ .
Payment Finalization: The Vault (U) signs the payment. The payment is only finalized if the S reveals the witness $t$ .
Result Delivery: Revealing $t$ allows the U to decrypt the result. Thus, payment finalization is cryptographically inseparable from result delivery.
Security: If the S tries to claim payment without delivering the result, the TEE prevents the generation of the pre-signature. If the U refuses to pay after receiving the result, the S can force an on-chain settlement using the adaptor signature, which reveals $t$ to the U, allowing them to claim the result.

C. Privacy-Preserving Liquidity Vault

To address privacy leakage from on-chain channel creation/closure:

Off-Chain Lifecycle: Clients deposit assets into a TEE-backed Liquidity Vault. ASC creation and closure happen entirely off-chain within the Vault's state.
Batch Settlement: The Vault aggregates multiple ASC settlements into a single on-chain transaction that reveals only the net balance changes, hiding individual client-provider interactions and transaction frequencies.
Trust Minimization: Even if the Vault is malicious or offline, participants can unilaterally trigger a "force-settle" on-chain transaction to recover their assets, ensuring sovereign control.

3. Key Contributions

Atomic Service Channels (ASCs): A novel protocol binding off-chain service execution to on-chain payments, enabling real-time, high-frequency micropayments.
TEE-Assisted Atomic Exchange: A protocol using adaptor signatures and TEEs to guarantee Exec-Pay-Deliver atomicity. Payment is finalized if and only if the service is correctly executed and the result is delivered.
Privacy-Preserving Liquidity Vault: A mechanism to decouple individual ASC lifecycles from on-chain transactions, aggregating settlements to preserve user privacy while maintaining asset security.
Implementation & Evaluation: A full implementation on both Bitcoin and Ethereum, demonstrating significant performance and cost improvements over x402.

4. Results

The authors implemented A402 and evaluated it against the x402 standard:

Performance (Throughput & Latency):
- Throughput: A402 achieved a peak of 2,875 Requests Per Second (RPS), which is ~~95x faster than Ethereum (~~30 TPS) and ~~410x faster than Bitcoin (~~7 TPS).
- Latency: End-to-end latency averaged ~350 ms (dominated by simulated service execution time), compared to minutes or hours for blockchain confirmation in x402.
Cost Efficiency:
- Ethereum: A402 reduced on-chain costs from O(n) (linear with requests) to O(1) (constant per channel/vault). For 100 requests, x402 cost ~$95.02, while A402 cost only $3.35 (Standard Mode) or $2.05 (Vault Mode).
- Bitcoin: Similar improvements were observed, with a 94x reduction in fees for 100 requests ($145.50 for x402 vs. $1.54 for A402).
Scalability: The system supports horizontal scaling by adding more Vault replicas, though coordination overhead slightly reduces throughput per replica.

5. Significance

A402 represents a foundational shift for Agentic Commerce:

Enables Machine-to-Machine (M2M) Economy: It provides the necessary financial rail for autonomous agents to transact without pre-established trust or identity, solving the "atomicity" problem that has hindered automated micropayments.
Trust Minimization: It achieves high security guarantees without requiring trust in the service provider, the client, or the intermediary (Vault), relying instead on hardware-enforced TEEs and cryptographic proofs.
Privacy & Scalability: By moving the bulk of interactions off-chain and aggregating settlements, it makes high-frequency, fine-grained micropayments economically and technically feasible on current blockchains.
Broad Applicability: The architecture supports diverse use cases, from real-time AI inference and data oracles to edge computing and IoT metering, where low latency and trustless verification are critical.

In summary, A402 bridges the gap between the programmable nature of blockchain and the execution requirements of autonomous agents, creating a secure, private, and scalable infrastructure for the future of the machine economy.