Disburse AI

Disburse AI — an agentic payment OS for humans and AI

Disburse AI is a programmable wallet + payments layer that lets AI agents, users, and merchants transact autonomously and privately. It combines account abstraction (ERC-4337), modular smart accounts (ERC-7579), native privacy via stealth addresses (ERC-5564), and HTTP-native payments with Coinbase’s x402 to enable true A2A (agent-to-agent) commerce and seamless user↔merchant flows on EVM chains.

What it does (at a glance)

• A2A payments over HTTP: Any agent can pay another agent/service inside an HTTP request using x402, ideal for API gating, per-request pricing, and machine commerce. We’re live on Polygon Amoy testnet for x402 flows.

• User & merchant payments: One-tap links, invoices, and checkout flows that work with or without wallets. Gasless by default, using ERC-4337 paymasters; fees can be sponsored or paid in tokens.

• Native privacy: Send to stealth addresses (ERC-5564) so recipients stay private on-chain; optional view keys enable compliance and receipts.

• Programmable rules: Auto-swap, spending limits, allowlists, time-locks, and policy-based routing implemented as ERC-7579 modules on top of ERC-4337 smart accounts.

• Ecosystem-ready: Designed to interop with Google’s A2A initiatives and merchant experiences that pair x402 with stablecoin settlement.

How it works (architecture)

1. Smart account core (ERC-4337 + ERC-7579)

ERC-4337 gives us smart-contract accounts, a UserOperation flow, bundlers, and paymasters for gas sponsorship / token-denominated fees. This powers gasless UX and session keys.

ERC-7579 standardizes modular smart accounts so we (and 3rd parties) can plug in modules—policy, automation, guardians, session keys—without lock-in.

Policy/automation modules we ship:

Auto-earn: Sweep idle balances into yield vaults.

Auto-swap/settle: Route receipts into a base token (per rule) and settle to a merchant.

Spending controls: Per-agent limits, rate-limits, time windows, allow/deny lists.

Session keys: Scoped keys for agents with granular permissions and expiries.

1. A2A (agent-to-agent) payments via x402 on Polygon Amoy

x402 revives HTTP 402 Payment Required: a server gates a resource; the client pays and retries with a payment-auth header, all inside standard HTTP. We use USDC on Polygon Amoy for testnet flows.

Under the hood we provide:

x402 client for agents (sign/pay/attach header automatically).

x402 gateway for servers (emit/verify payment instructions; validate on-chain settlement before responding). GitHub

1. User & merchant payments

Checkout & links: Generate intent-links or QR-codes; customers pay from any wallet or via Disburse smart accounts.

Gasless by default: Our paymaster sponsors gas or accepts ERC-20 for fees; great for mainstream UX.

Recurring & metered: Rules authorize recurring debits or metered usage (e.g., per API call), enforced by modules and session keys.

1. Native privacy with ERC-5564 stealth addresses

• Stealth meta-address: Merchants/users publish a meta-address; senders derive a one-time stealth address so funds arrive privately. Recipients scan with a view key and spend with a spend key; optional ERC-6538 registry for discovery.

• Compliance toggles: Share view keys or emit encrypted memos for audits and receipts without doxxing primary accounts. (Trade-offs documented in the ERC and ecosystem guides.)

• Developer & operator experience

How it’s made

Disburse AI is built by combining account abstraction, modular smart accounts, privacy primitives, and x402-based payments on Polygon Amoy testnet.

Core Smart Account Stack

We use ERC-4337 for smart accounts, gas abstraction, and UserOperations.

ERC-7579 lets us attach modules for automation (rules, auto-swap, auto-earn, session keys).

Accounts are deployed via a factory using CREATE2 so agents can have deterministic addresses.

x402 (A2A payments) on Polygon Amoy

We integrated Coinbase’s x402 standard so agents can pay for APIs and services inside HTTP requests.

Agents receive a 402 Payment Required response, settle the payment in USDC on Polygon Amoy, and retry the request with the x402 auth header.

We built both the client SDK (for agents) and the server gateway middleware that verifies on-chain payments.

Gasless Transactions

We run a 4337 bundler and paymaster to enable gasless transactions.

The paymaster can sponsor gas or accept ERC-20 tokens for fees.

Native Privacy

For private payments, we implemented ERC-5564 stealth addresses.

Senders generate one-time stealth addresses using the recipient’s published meta-address, so payments are unlinkable on-chain.

Recipients scan and spend using view/spend keys.

Programming & Automation

Rules like auto-swap, routing, session keys, and rate limits are built as ERC-7579 modules.

Agents can trigger actions without exposing owner keys.

Backend & Infra

Node.js + TypeScript for SDKs and x402 gateway.

Solidity + Foundry for smart contracts.

Alchemy/QuickNode for RPC and mempool watching.

Redis + Postgres for minimal tracking, plus Tenderly for debugging.

Notable hacky bits

We allow “optimistic” x402 verification by checking mempool transactions to speed up responses.

Built a token-fee paymaster that swaps collected ERC-20 to native gas in the background.

Used encrypted off-chain storage for stealth metadata instead of putting view-keys on-chain.