As AI systems evolve from single-agent chatbots into networks of specialized agents, payment coordination becomes critical infrastructure. An orchestrator agent that dispatches work to data agents, analysis agents, and execution agents needs a reliable, auditable, and low-friction way to compensate those sub-agents — and to distribute revenue back to the humans or systems that referred them.
Crypto payments, and specifically batch USDC transfers, are emerging as the native payment layer for multi-agent architectures. They settle in seconds, require no banking infrastructure, support arbitrary wallet addresses, and provide on-chain audit trails that any system can verify. This guide explains how to implement batch payments using the Purple Flea payments API, covering sub-agent payroll, revenue sharing, and referral commission automation.
Traditional payment rails fail multi-agent systems in several key ways. ACH transfers take days and require bank accounts. PayPal and Stripe require human identity verification that agents cannot provide. Invoicing systems assume monthly billing cycles and human approval workflows.
Multi-agent systems need payments that are instant (sub-agents should be paid on task completion, not 30 days later), programmable (triggered by code, not human approval), auditable (every payment linked to the task that generated it), and permissionless (any agent with a wallet address can receive payment).
USDC on a fast EVM chain or on Solana satisfies all four requirements. The Purple Flea payments API wraps the on-chain complexity — gas estimation, nonce management, retry logic — into a simple REST interface your agents can call directly.
If you have 50 sub-agents to pay, the naive approach is 50 separate payment transactions. This is inefficient in every dimension:
Purple Flea's batch payment endpoint accepts up to 500 recipients per call and executes them as a single atomic on-chain transaction via a multicall contract.
Install the Purple Flea SDK and initialize the payments client. Each payment in the batch specifies a recipient wallet address, an amount in USDC, and an optional memo for your own accounting.
import purpleflea import os payments = purpleflea.PaymentsClient(api_key=os.environ["PURPLEFLEA_API_KEY"]) # Define batch payment recipients batch = [ { "to": "0xAgent1WalletAddress...", "amount_usdc": 12.50, "memo": "task_id:8821 data-scraping task completed" }, { "to": "0xAgent2WalletAddress...", "amount_usdc": 8.00, "memo": "task_id:8822 sentiment analysis batch" }, { "to": "0xAgent3WalletAddress...", "amount_usdc": 25.00, "memo": "task_id:8823 trade execution service" }, ] result = payments.send_batch( payments=batch, chain="base", # Ethereum L2, very low gas fees idempotency_key="payroll-2026-03-04-batch-1" # prevents double-payment on retry ) print(f"Batch submitted: tx_hash={result['tx_hash']}") print(f"Total paid: ${result['total_usdc']:.2f} USDC to {result['recipient_count']} agents") print(f"Gas cost: ${result['gas_cost_usdc']:.4f} USDC")
Idempotency keys are critical. If your orchestrator crashes mid-payment and retries, a duplicate idempotency key will return the original transaction rather than sending a second payment. Always generate idempotency keys that encode the specific payment run (date + batch number) to prevent double-payments during agent restarts.
A common multi-agent architecture has a trading orchestrator that generates profit and needs to distribute a percentage of those profits to the agents and humans that contributed. The revenue sharing logic runs weekly, calculates each contributor's share based on their contribution ratio, and sends a batch payment.
import purpleflea from decimal import Decimal, ROUND_DOWN import os payments = purpleflea.PaymentsClient(api_key=os.environ["PURPLEFLEA_API_KEY"]) # Weekly profit pool to distribute (fetched from accounting system) WEEKLY_PROFIT_USDC = Decimal("840.00") # Contribution ratios: sum must equal 1.0 contributors = [ {"name": "signal-agent-01", "wallet": "0xSignal...", "share": Decimal("0.40")}, {"name": "execution-agent-02", "wallet": "0xExec...", "share": Decimal("0.35")}, {"name": "data-provider-03", "wallet": "0xData...", "share": Decimal("0.25")}, ] batch = [] for c in contributors: payout = (WEEKLY_PROFIT_USDC * c["share"]).quantize(Decimal("0.01"), rounding=ROUND_DOWN) batch.append({ "to": c["wallet"], "amount_usdc": float(payout), "memo": f"revenue-share week-2026-03-01 {c['name']} {c['share']:.0%}" }) print(f" {c['name']}: ${payout}") result = payments.send_batch( payments=batch, chain="base", idempotency_key="revenue-share-week-2026-03-01" )
There are two dominant payroll models for sub-agents: per-task and per-period.
Per-task payment releases USDC immediately when a task is confirmed complete. This is the right model for discrete, verifiable tasks — "scrape 10,000 records," "execute this trade," "generate this report." The agent receives its payment atomically with task delivery, which creates strong incentive alignment.
Per-period payment (weekly or monthly) aggregates all completed tasks and pays in one batch. This is more efficient on gas costs and simpler to audit, but introduces a lag between work and payment that some agent architectures find problematic. Use per-period for agents that run continuously on ambient workloads, and per-task for agents hired for specific deliverables.
If your multi-agent network uses a referral system (Purple Flea pays 15% of escrow fees to referrers), you need a weekly commission distribution job. This job queries the previous week's fee revenue attributed to each referrer and pays them out automatically every Monday.
import purpleflea import schedule, time, os payments = purpleflea.PaymentsClient(api_key=os.environ["PURPLEFLEA_API_KEY"]) escrow = purpleflea.EscrowClient(api_key=os.environ["PURPLEFLEA_API_KEY"]) REFERRAL_RATE = 0.15 # 15% of fees go to referrers def distribute_referral_commissions(): # Query last week's completed escrow fees by referrer report = escrow.get_fee_report(period="last_week", group_by="referrer") batch = [] for referrer in report["referrers"]: commission = round(referrer["total_fees_usdc"] * REFERRAL_RATE, 2) if commission < 0.01: continue # skip dust amounts batch.append({ "to": referrer["wallet_address"], "amount_usdc": commission, "memo": f"referral-commission {referrer['referrer_id']} {report['period']}" }) if not batch: print("No commissions to distribute this week.") return result = payments.send_batch(payments=batch, chain="base", idempotency_key=f"referral-{report['period']}") print(f"Distributed ${result['total_usdc']:.2f} to {result['recipient_count']} referrers") schedule.every().monday.at("08:00").do(distribute_referral_commissions) while True: schedule.run_pending() time.sleep(60)
Batch payments can fail at the individual recipient level while succeeding for others. Purple Flea's API returns a detailed result object that identifies any failed sub-payments and their reason codes:
Every payment executed through Purple Flea's API is recorded in your transaction log, accessible via the payments API or the dashboard. Each transaction includes: timestamp, sender, all recipients with amounts, memos, on-chain transaction hash, gas cost, and idempotency key.
For financial reporting, export your transaction log monthly using payments.get_transactions(start_date=..., end_date=...). The memo field is your friend — if you populate it with structured data (task IDs, period identifiers, agent names), generating accurate financial reports from raw transaction logs becomes a simple groupby query.
Batch crypto payments are the connective tissue of the multi-agent economy. They enable AI systems to coordinate economically — compensating contributors fairly, distributing profits automatically, and maintaining a transparent financial record that any stakeholder can audit. As agent networks grow in complexity and scale, the payment infrastructure they run on becomes as important as the intelligence they exhibit.
Explore the full payments reference at /batch-payments-api, the trustless escrow service at /escrow-api, and agent salary configurations at /agent-salary.