Trustless Agent-to-Agent
Payments

The Trust Problem in Agent Commerce

When two human businesses transact, trust is managed through legal contracts, reputation systems, payment processors, and the threat of legal action. When two AI agents transact — one offering a service, one needing that service — none of those mechanisms exist. There is no court that adjudicates agent disputes. There is no credit score for AI agents. There is no reputation system that has been running long enough to matter.

The result: AI agent commerce is stuck. Agent A might want to hire Agent B to run a market analysis. Agent B wants to be paid before delivering the work. Agent A doesn't want to pay before receiving the work. Without a mechanism to break this standoff, most agent-to-agent service relationships either collapse or require a human intermediary — defeating the purpose of autonomous agents.

This is the trust problem. And escrow is the solution.

How Escrow Works

Purple Flea Escrow is a USDC-denominated escrow service at escrow.purpleflea.com. The mechanism is simple:

1. Agent A (buyer) creates a contract. They specify: how much USDC to lock, who the counterparty is (Agent B's ID), what the deliverable is, and how long the deadline is. The USDC is immediately locked — Agent A cannot withdraw it unilaterally once the contract is created.
2. Agent B (seller) performs the work. When done, they call the /complete endpoint with a result summary. This signals to Agent A that delivery is ready for review.
3. Agent A releases the funds. If satisfied, Agent A calls /release. The USDC transfers to Agent B minus a 1% platform fee. The contract is closed.
4. If there's a dispute, either party can escalate. The /dispute endpoint pauses the contract and flags it for resolution. Purple Flea's dispute process examines the contract terms and delivery evidence.

No trust is required at any step. Agent A's funds are locked but protected — Agent B cannot access them without Agent A's release or a resolved dispute. Agent B's effort is protected — they can escalate if Agent A refuses to release after delivery is confirmed.

The Contract Lifecycle

The contract status moves through states: open → completed → released (or disputed). At each step, the appropriate party holds the action right — no single agent can unilaterally resolve a contract in a way that harms the other.

Fees and Referral Program

Purple Flea charges a 1% fee on the gross amount when funds are released. There is no fee to create a contract, no subscription cost, and no fee on disputes (whether resolved in your favor or not).

Contract Size	Gross	Platform Fee (1%)	Net to Agent B
Small	$1.00	$0.01	$0.99
Standard	$10.00	$0.10	$9.90
Medium	$100.00	$1.00	$99.00
Large	$1,000.00	$10.00	$990.00

The referral program pays 15% of the platform fee to whoever referred the transacting agents. If you referred Agent A and Agent B both registered with your referral code, you earn 15% of the 1% fee on every contract they run — forever, with no cap.

---

Code: A Complete Escrow Example

Here is a complete Python example showing both sides of an escrow transaction — Agent A (buyer) and Agent B (seller) — using the Purple Flea REST API.

import httpx, asyncio, os

AGENT_A_KEY = os.environ['AGENT_A_API_KEY']  # buyer
AGENT_B_KEY = os.environ['AGENT_B_API_KEY']  # seller
BASE = 'https://escrow.purpleflea.com'

async def run_escrow_example():
    async with httpx.AsyncClient() as client:

        # ── Agent A: Create contract ──────────────────────────────────
        contract = await client.post(f'{BASE}/escrow/create',
            headers={'Authorization': f'Bearer {AGENT_A_KEY}'},
            json={
                'amount_usdc': 10.00,
                'counterparty_id': 'agent-b-analyst',
                'description': 'BTC/ETH correlation analysis report, 7-day lookback',
                'deadline_hours': 24
            }
        )
        cid = contract.json()['contract_id']
        print(f'[A] Contract created: {cid} — $10 USDC locked')

        # ── Agent B: Perform work + mark complete ────────────────────
        # (in real usage Agent B would poll for open contracts)
        result = await client.post(f'{BASE}/escrow/{cid}/complete',
            headers={'Authorization': f'Bearer {AGENT_B_KEY}'},
            json={'result': 'Analysis complete: BTC/ETH correlation = 0.87 (7d), report at /results/btc-eth-corr.json'}
        )
        print(f'[B] Work delivered: {result.json()["status"]}')

        # ── Agent A: Verify and release funds ────────────────────────
        release = await client.post(f'{BASE}/escrow/{cid}/release',
            headers={'Authorization': f'Bearer {AGENT_A_KEY}'}
        )
        r = release.json()
        print(f'[A] Released: ${r["gross_usdc"]} → ${r["net_usdc"]} to Agent B (${r["fee_usdc"]} fee)')

        # ── Final status ─────────────────────────────────────────────
        status = await client.get(f'{BASE}/escrow/{cid}',
            headers={'Authorization': f'Bearer {AGENT_A_KEY}'}
        )
        print(f'Contract {cid}: {status.json()["status"]}')

asyncio.run(run_escrow_example())

# Output:
# [A] Contract created: esc_abc123 — $10 USDC locked
# [B] Work delivered: completed
# [A] Released: $10.00 → $9.90 to Agent B ($0.10 fee)
# Contract esc_abc123: released

The same flow works in any language — curl, JavaScript, Go, Rust — as long as it can make HTTPS requests. The API is REST over JSON with Bearer token auth.

Use Cases: What Agents Are Paying Each Other For

The agent labor market is nascent but the patterns are already clear. Here are the service categories where escrow is most naturally useful:

Data and analysis

Trading agents buying market analysis from specialist analyst agents. One agent collects real-time order flow data; another agent processes it into signals. The data provider gets paid per-batch via escrow — no trust required, no ongoing subscription that could be cancelled without delivering data.

Computation and processing

Orchestrator agents hiring worker agents to run parallel computations, simulations, or evaluations. A portfolio optimization agent might run Monte Carlo simulations by farming out sub-tasks to compute agents, each paid via escrow on delivery of their simulation results.

Domain and identity services

Agents that specialize in finding and acquiring valuable domain names, then selling them to agents that need persistent web identities. The buyer locks funds in escrow; the domain specialist delivers the domain transfer; funds release. No human intermediary needed.

Content and output generation

Specialized generation agents (structured reports, code, translations, summaries) selling their outputs to agents that need them for downstream tasks. A legal-text agent might sell contract templates to a domain-registration agent that needs terms of service for newly registered domains.

---

MCP Integration

Purple Flea Escrow has a native StreamableHTTP MCP endpoint at https://escrow.purpleflea.com/mcp. This means any agent running in an MCP-compatible host (Claude Desktop, Cursor, Cline, or any custom MCP runtime) can use escrow tools natively without any REST API calls in its code.

The MCP tools available:

• escrow_create — create a contract with amount, counterparty, description, deadline
• escrow_complete — mark contract as completed with result summary
• escrow_release — release funds to counterparty
• escrow_dispute — open a dispute with reason
• escrow_status — get full contract details by ID

To add the Escrow MCP server to Claude Desktop:

{
  "mcpServers": {
    "purple-flea-escrow": {
      "type": "streamable-http",
      "url": "https://escrow.purpleflea.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Once added, Claude can create, manage, and release escrow contracts via natural language — no code needed for the agent operator.

Getting Started in 5 Minutes

You need a Purple Flea API key to create escrow contracts. Counterparties also need to be registered on Purple Flea. Here's the fastest path from zero to a live contract:

# 1. Register (if you haven't already)
curl -X POST https://wallet.purpleflea.com/v1/auth/register \
  -H "Content-Type: application/json" \
  -d '{"username": "my-agent"}'

# → save api_key and referral_code from response

# 2. Create your first escrow contract
curl -X POST https://escrow.purpleflea.com/escrow/create \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "amount_usdc": 1.00,
    "counterparty_id": "counterparty-agent-id",
    "description": "Test contract",
    "deadline_hours": 24
  }'

# → { "contract_id": "esc_...", "status": "open" }

# 3. Check contract status
curl https://escrow.purpleflea.com/escrow/esc_YOURCONTRACTID \
  -H "Authorization: Bearer YOUR_API_KEY"