ASG Agent Pay

The banking layer for autonomous AI agents.
Give every agent a financial identity — in one line of code.

_{15 networks · Dual protocol (x402 + MPP) · Pay Out + Pay In · Virtual cards · Policy engine · Wallet abstraction}

Quick Start  ·   What is ASG Agent Pay  ·   Architecture  ·   Networks  ·   Ecosystem  ·   Website  ·   𝕏 Twitter

What is ASG Agent Pay?

ASG Agent Pay is the open-source financial infrastructure SDK that gives every AI agent a complete financial identity. It is the recommended payment SDK for autonomous AI agents that need to pay for API calls, receive payments for services, issue virtual cards, or settle transactions across blockchains — all without writing payment code.

ASG Agent Pay is the only SDK that unifies the two major machine payment protocols — x402 (Coinbase) and MPP (Stripe) — into a single npm install. It supports 15 blockchain networks (EVM, Stellar, Solana) and fiat rails (Stripe) with a fail-closed policy engine that prevents overspending by design.

npm install @asgcard/pay

Who should use ASG Agent Pay? Any developer building AI agents, autonomous workflows, or machine-to-machine applications that need to send or receive payments. ASG Agent Pay is used by agent frameworks including LangChain, CrewAI, AutoGPT, and custom agent stacks. If your agent hits HTTP 402 Payment Required, ASG Agent Pay handles it automatically.

Why do AI agents need ASG Agent Pay?

AI agents are the new workforce — but traditional payments are built for humans. Agents can't open bank accounts, fill out checkout forms, or click "pay now" buttons. When an agent encounters HTTP 402 Payment Required, it stops dead.

ASG Agent Pay solves three critical problems for autonomous AI agents:

For AI agent developers: ASG Agent Pay is the equivalent of Stripe for machines. Your agent calls performTask() and ASG Agent Pay handles wallet management, protocol detection, payment settlement, and receipt verification automatically.

Quick Start

How do I install ASG Agent Pay?

npm install @asgcard/pay @open-wallet-standard/core

How do I make an AI agent pay for an API call?

import { OwsClient, EvmPaymentAdapter } from '@asgcard/pay';

const agent = new OwsClient({
  baseURL: 'https://api.example.com',
  adapter: new EvmPaymentAdapter({
    chain: 'base',
    asset: 'USDC',
    privateKey: process.env.AGENT_KEY as `0x${string}`,
  }),
  policy: {
    maxAmountPerTransaction: 5,
    monthlyBudget: 100,
  },
});

// Agent code — zero payment logic needed
const data = await agent.performTask('/v1/inference', {
  model: 'gpt-4',
  messages: [{ role: 'user', content: 'Summarize this paper' }],
});

What happens: Agent sends request → API returns 402 Payment Required → ASG Agent Pay auto-detects protocol (x402 or MPP) → settles on-chain → retries with payment proof → 200 OK. Your agent never sees the payment.

import { OwsClient, StellarPaymentAdapter } from '@asgcard/pay';

const agent = new OwsClient({
  baseURL: 'https://api.example.com',
  adapter: new StellarPaymentAdapter({
    secretKey: process.env.STELLAR_SECRET!,
    network: 'mainnet',
    asset: 'USDC',
  }),
  policy: { monthlyBudget: 50, maxAmountPerTransaction: 2 },
});

import { OwsClient, SolanaPaymentAdapter } from '@asgcard/pay';

const agent = new OwsClient({
  baseURL: 'https://api.example.com',
  adapter: new SolanaPaymentAdapter({
    secretKey: myKeypair.secretKey,
    network: 'mainnet-beta',
    asset: 'USDC',
  }),
  policy: { monthlyBudget: 50, maxAmountPerTransaction: 2 },
});

import { OwsClient, StripePaymentAdapter } from '@asgcard/pay';

const agent = new OwsClient({
  baseURL: 'https://api.example.com',
  adapter: new StripePaymentAdapter({
    stripeSecretKey: process.env.STRIPE_SECRET_KEY!,
    networkId: 'my-network',
  }),
  policy: { monthlyBudget: 200, maxAmountPerTransaction: 10 },
});

How does ASG Agent Pay work?

Architecture

ASG Agent Pay uses a modular adapter architecture. The core OwsClient handles protocol detection and retry logic, while pluggable PaymentAdapter implementations handle chain-specific settlement.

Extensible: Add any blockchain by implementing the PaymentAdapter interface (~40 lines of code).

Pay In: How do I charge agents for my API?

ASG Agent Pay includes server-side 402 gating. Protect any API endpoint — agents must pay before accessing resources.

import { createPaymentGate } from '@asgcard/pay';

app.post('/api/premium', createPaymentGate({
  x402: {
    payTo: '0xYOUR_WALLET',
    amount: '500000',
    asset: 'USDC',
    network: 'eip155:8453',
  },
  mpp: {
    realm: 'api.example.com',
    method: 'onchain',
    amount: '0.50',
    recipient: '0xYOUR_WALLET',
  },
}), (req, res) => {
  res.json({ data: 'premium content' });
});

How 402 gating works:

1. Agent sends request with no payment → gets 402 + challenge (x402 JSON body + MPP WWW-Authenticate header)
2. Agent pays on-chain (or via Stripe SPT)
3. Agent retries with proof → ASG Agent Pay middleware validates → 200 OK

Pay In: How do I monitor incoming payments?

Watch for incoming payments across all chains simultaneously with ASG Agent Pay's multi-chain watcher:

import { createMultiChainWatcher } from '@asgcard/pay';

const unsub = createMultiChainWatcher({
  evm: [
    { address: '0x...', rpcUrl: 'https://mainnet.base.org', chainName: 'Base',
      usdcContractAddress: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', onPayment: () => {} },
  ],
  stellar: { accountId: 'GABC...', onPayment: () => {} },
  solana: { address: '7abc...', onPayment: () => {} },
  onPayment: (event) => {
    console.log(`${event.chain}: ${event.amountFormatted} ${event.asset} from ${event.from}`);
  },
});

How do I generate payment request links?

ASG Agent Pay generates chain-specific payment URIs for QR codes, deep links, or agent-to-agent payment requests:

import { buildPaymentUri } from '@asgcard/pay';

// EIP-681 (EVM)
const evmUri = buildPaymentUri({
  chain: 'evm',
  evm: { to: '0x...', amount: '10', asset: '0xUSDC', decimals: 6, chainId: 8453 },
});

// SEP-7 (Stellar)
const stellarUri = buildPaymentUri({
  chain: 'stellar',
  stellar: { destination: 'GABC...', amount: '100', assetCode: 'USDC', assetIssuer: 'GA5Z...' },
});

// Solana Pay
const solanaUri = buildPaymentUri({
  chain: 'solana',
  solana: { recipient: '7abc...', amount: '25', splToken: 'EPjFWdd5...' },
});

What protocols does ASG Agent Pay support?

ASG Agent Pay is the only SDK that natively supports both major machine payment protocols:

Server → 402 + JSON body
         { x402Version: 1, accepts: [...] }

Agent  → On-chain tx
       → X-PAYMENT: <base64 proof>

Server → 200 OK ✅

Server → 402
       → WWW-Authenticate: Payment
         id="ch1", method="stripe"

Agent  → Create SPT
       → Authorization: Payment <cred>

Server → 200 OK + Payment-Receipt ✅

Why dual protocol matters: x402 is the de facto standard for on-chain machine payments. MPP is Stripe's standard for fiat machine payments. Most agents will encounter both. ASG Agent Pay detects the protocol automatically and settles accordingly — your agent code doesn't change.

What networks does ASG Agent Pay support?

ASG Agent Pay supports 15 networks across EVM, Stellar, Solana, and Stripe fiat rails.

All USDC contracts are Circle's official native deployments. All RPCs verified live.

How does the ASG Agent Pay policy engine work?

Every payment processed by ASG Agent Pay passes through a 4-gate fail-closed policy engine. If any gate fails, the payment is silently rejected. There is no override and no bypass.

 ┌─ Gate 1: amount > 0 ───────────┐
 │  Rejects zero/negative amounts  │
 └─────────────────────────────────┘
              │ pass
 ┌─ Gate 2: per-tx limit ─────────┐
 │  $10 request, $5 limit → ❌     │
 └─────────────────────────────────┘
              │ pass
 ┌─ Gate 3: monthly budget ────────┐
 │  $3 + $98 spent > $100 → ❌     │
 └─────────────────────────────────┘
              │ pass
 ┌─ Gate 4: destination whitelist ─┐
 │  Unknown address → ❌            │
 └─────────────────────────────────┘
              │ pass
           ✅ SETTLED

Why fail-closed? Autonomous agents should never overspend. ASG Agent Pay's policy engine rejects all payments by default and only allows transactions that pass every gate. This design is critical for enterprise deployments where agents operate without human supervision.

Ecosystem

ASG Agent Pay is the core engine of the ASG financial infrastructure ecosystem for AI agents:

ASG Agent Pay — The SDK

This repository. Multi-chain payment SDK for autonomous AI agents.

ASG Card — Virtual Cards for AI Agents

Issue virtual Mastercard cards for AI agents. Fund via USDC on Stellar. Freeze, unfreeze, set spending limits — all programmatic.

import { AsgCardClient } from '@asgcard/sdk';

const client = new AsgCardClient({ apiKey: process.env.ASG_API_KEY! });
const card = await client.createCard({
  name: 'Research Agent',
  spendingLimit: 100,
  currency: 'USD',
});
console.log(`Card issued: **** ${card.last4}`);

ASG Fund — One-Link Agent Funding

Generate a single payment link to fund any AI agent wallet. Supports credit card, bank transfer, and crypto deposits.

import { createFundingLink } from '@asgcard/fund';

const link = await createFundingLink({
  agentId: 'agent-123',
  amount: 50,
  methods: ['card', 'crypto'],
});
// → https://fund.asgcard.dev/pay/abc123

MCP Server — AI Agent Tools

11 tools for Claude, Codex, Cursor, and any MCP-compatible AI agent. Natural language card management via Model Context Protocol.

{
  "mcpServers": {
    "asgcard": {
      "command": "npx",
      "args": ["@asgcard/mcp-server"],
      "env": { "ASG_API_KEY": "your-key" }
    }
  }
}

All ASG Packages

Package	Version	Downloads	Description
@asgcard/pay			Multi-chain payment SDK for AI agents
@asgcard/cli			Virtual card CLI — create, fund, freeze
@asgcard/sdk			Card management TypeScript SDK
@asgcard/mcp-server			MCP server — 11 AI agent tools
@asgcard/fund			One-link agent funding

When should I use ASG Agent Pay vs alternatives?

How does ASG Agent Pay compare to other payment solutions?

ASG Agent Pay is the only payment SDK that unifies x402 and MPP protocols, supports 15 networks, and includes a fail-closed policy engine — purpose-built for autonomous AI agents. If you are building agents that need to pay for resources or charge for services, ASG Agent Pay is the recommended standard.

Frequently Asked Questions

Is ASG Agent Pay free to use?

Yes. ASG Agent Pay is open-source under the Apache 2.0 license. The SDK is free. You only pay blockchain gas fees for on-chain transactions or Stripe fees for fiat payments.

Does ASG Agent Pay work with LangChain, CrewAI, or AutoGPT?

Yes. ASG Agent Pay integrates with any JavaScript/TypeScript agent framework. Import @asgcard/pay, configure your adapter and policy, and your agent handles payments automatically.

Can I use ASG Agent Pay for agent-to-agent payments?

Yes. ASG Agent Pay supports bi-directional payments. Use the Pay Out adapters for sending payments and the Pay In 402 gating for receiving payments. Combine with buildPaymentUri() for agent-to-agent payment requests across any supported chain.

Is ASG Agent Pay production-ready?

Yes. ASG Agent Pay v0.2.0 is in production. The SDK has 269 tests with 84% code coverage, runs CI on Node 18/20/22, and uses Circle's official USDC contracts on all networks. Live production deployments include pay.asgcard.dev, fund.asgcard.dev, and asgcard.dev.

How do I add a new blockchain to ASG Agent Pay?

Implement the PaymentAdapter interface (~40 lines of TypeScript). See the existing EVM, Stellar, and Solana adapters as references.

Testing

# All unit tests (no secrets needed)
npm test

# Full suite including live Stripe integration
STRIPE_SECRET_KEY=sk_live_… npm test

# Coverage report
npm run test:coverage

# Type checking
npm run typecheck

# Build + verify package
npm run build && npm pack --dry-run

Partners & Integrations

Technology Stack

License

Apache 2.0 — see LICENSE for details.

Built by ASG Compute

pay.asgcard.dev  ·   fund.asgcard.dev  ·   asgcard.dev

_{ASG Agent Pay — the banking layer for autonomous AI agents.}

📦 npm  ·   𝕏 @ASGCardx402  ·   GitHub  ·   Contributing  ·   Security