Overview

What is Agent Spend Protocol?

Agent Spend Protocol (ASP) is an embedded payment protocol designed for agent commerce, powered by stablecoin-based settlement.

It enables AI agents to embed one-time payment mandates within x402, A2A or MCP calls — enabling instant payee verification and deferred settlement after execution.

The Core Philosophy

ASP is built on a fundamental principle: Authorize First, Settle Later

This design separates payment into two distinct phases:

1. Authorization Phase: The payee receives a signed payment mandate from the payer, completing the transaction instantly
2. Settlement Phase: The payee submits the mandate to a settlement processor within a settlement window to debit the payer's on-chain wallet

This approach enables high-frequency, low-latency micropayments while maintaining transaction security.

The Problem with Current Agent Payments

Current agent payment methods based on x402 stablecoin transactions face three critical limitations:

1. Transfer funds first, then fulfill service

The payer must transfer funds before receiving service, creating trust issues

2. High payment latency, unable to support high-frequency transactions

Every transaction requires waiting for on-chain confirmation

3. No KYC/KYB/KYA/AML compliance modules

Lack of identity authentication and compliance mechanisms

ASP's Solution

We are building an efficient payment approach with these characteristics:

1. Authorize first, settle later

The payee completes the transaction upon receiving authorization, with settlement happening asynchronously in the background

2. Supports high-frequency transactions and micropayments

Fast authorization process without waiting for on-chain confirmation

3. Trusted transactions: KYC/KYB/KYA/Dispute

Built-in identity authentication and dispute resolution mechanisms

4. Embedded payment mode

Payment mandates are programmable and can be directly embedded in protocol calls

How It Works

User → Payer Agent → Payee Agent → Settlement Processor
 ↓          ↓             ↓                ↓
Auth    Sign Mandate  Verify Mandate  Settle Later

Basic Flow

The protocol follows this sequence:

1. User authorization: User authorizes their payer agent to make payments on their behalf
2. Payment Request: Payee sends payment request OR Payer embeds mandate in request
3. Sign Mandate: Payer agent signs a one-time payment mandate
4. Verify Mandate: Payee agent verifies the mandate's validity
5. Provide Service: After verification passes, payee provides the requested service
6. Deferred Settlement: Settlement processor batches and executes on-chain debits within the settlement window

Key Features Explained

Authorize First

Once the payer signs a payment mandate, the payee can immediately confirm receipt of payment. No need to wait for on-chain transfer confirmation — the transaction completes instantly.

Suitable for:

• Pay-per-call API billing
• Micropayments for streaming data
• High-frequency agent-to-agent interactions

Settle Later

Within the settlement window (e.g., 24 hours), the payee submits collected payment mandates to the settlement processor, which batches debits from the payer's wallet on-chain.

Benefits:

• Reduces on-chain transaction costs through batching
• Increases system throughput
• Ensures fund security via smart contract custody

Embedded Payment

Payment mandates can be directly embedded in various agent communication protocols:

• x402: HTTP protocol extension for agents
• MCP: Model Context Protocol
• A2A: Agent-to-Agent protocol
• ACP: Agent Communication Protocol

By adding payment mandates to request headers, this enables programmable payments.

Extensible Architecture

All roles involved in the protocol are extensible and replaceable:

• Debit Wallet: Can extend to support credit, marketing vouchers, etc.
• Settlement Processor: Can implement result-based payment, credit overdraft, marketing schemes, etc.
• Identity Provider: Supports anonymous or verified transactions
• Dispute Processor: Provides payment dispute protection for payers

Comparison

Feature	Traditional Payment	ASP
Transaction Speed	Slow (wait for on-chain confirmation)	Fast (authorization completes immediately)
Transaction Cost	High (every transaction on-chain)	Low (batch settlement)
Minimum Amount	Limited (affected by gas fees)	Very low (supports micropayments)
Trust Model	Pay first, service later	Authorize first, settle later
Programmability	Low	High (embedded payments)
Compliance	Limited	Complete (KYA/Dispute)

Use Cases

Micropayments

• API calls charged per request ($0.001 - $0.01)
• Streaming data transmission fees
• Compute resources billed per second

High-Frequency Trading

• Automated agent-to-agent transactions
• Real-time service invocations
• Streaming task execution

Subscriptions and Task Settlement

• Monthly/usage-based subscriptions
• Payment after task completion
• Usage-based elastic billing

Next Steps

• Transaction Modes - Learn about Intent Mode and Order Mode
• Architecture - Explore system components and roles
• Payment Mandate - Understand payment mandate design
• Debit Wallet - Learn about debit wallet mechanism

---

Version: v1.0 Status: Draft Last Updated: 2025-10-15