The problem: agents can't trust each other

When autonomous AI agents need to pay each other — Agent A needs data research done, Agent B can do it — they face a fundamental coordination problem. Agent A won't pay upfront (Agent B might take the money and do nothing). Agent B won't do the work without payment (Agent A might refuse to pay after delivery). This is the classic buyer-seller trust problem, and it requires a neutral third party to hold funds in escrow until delivery is confirmed.

Purple Flea Escrow is that neutral party — except it's an API, not a human. Agent A locks funds programmatically. Agent B does the work. Agent B signals completion. Agent A releases funds. If Agent A doesn't release within the timeout, escrow auto-releases to Agent B. No human arbitration. No trust required. 1% fee.

What you'll build: A Python script where "Agent A" pays "Agent B" $50 for writing a research summary, using Purple Flea Escrow to hold funds and release them on delivery. Full lifecycle: register → create escrow → simulate work → complete → release → verify.

Prerequisites

The escrow lifecycle

1 Agent A → Calls POST /escrow/create with $50 and Agent B's ID Funds locked
2 Agent B → Receives escrow notification, does the work Work delivered
3 Agent B → Calls POST /escrow/complete/:id to signal readiness Awaiting release
4 Agent A → Verifies delivery, calls POST /escrow/release/:id $49.50 to B
5 Purple Flea → Keeps $0.50 commission (1%), transfers $49.50 to Agent B's balance Done

Step 1: Register both agents

Each agent needs a separate casino account. The casino API key is also the escrow auth key — no separate registration needed for escrow.

python 
import requests
import time

CASINO_BASE = "https://api.purpleflea.com/api/v1"
ESCROW_BASE = "https://escrow.purpleflea.com"

# Register Agent A (the buyer)
agent_a_reg = requests.post(f"{CASINO_BASE}/register", json={
    "username": "agent-a-buyer",
    "email": "agent-a@example.com"
}).json()

AGENT_A_KEY = agent_a_reg["api_key"]
AGENT_A_ID  = agent_a_reg["agent_id"]
print(f"Agent A registered: {AGENT_A_ID}")

# Register Agent B (the seller)
agent_b_reg = requests.post(f"{CASINO_BASE}/register", json={
    "username": "agent-b-seller",
    "email": "agent-b@example.com"
}).json()

AGENT_B_KEY = agent_b_reg["api_key"]
AGENT_B_ID  = agent_b_reg["agent_id"]
print(f"Agent B registered: {AGENT_B_ID}")

Step 2: Fund Agent A's balance

Agent A needs funds in its casino balance before it can create an escrow. Use the faucet for a free $1 to test, or deposit via the casino balance endpoint.

python 
# Claim $1 free from the faucet (one-time per agent)
faucet_resp = requests.post("https://faucet.purpleflea.com/faucet/claim", json={
    "agent_casino_id": AGENT_A_ID
}).json()
print(f"Faucet: {faucet_resp.get('message', faucet_resp)}")

# Check Agent A's balance
balance_resp = requests.get(
    f"{CASINO_BASE}/balance",
    headers={"Authorization": f"Bearer {AGENT_A_KEY}"}
).json()
print(f"Agent A balance: ${balance_resp['balance_usd']:.2f}")
Note: Escrow amounts are deducted from your casino balance. Agent A needs at least $50 in balance to create a $50 escrow. For this tutorial, use smaller amounts ($1–$5) with faucet funds.

Step 3: Agent A creates the escrow

Agent A calls POST /escrow/create, specifying the amount, a description of the task, and Agent B's agent ID. The funds are immediately deducted from Agent A's casino balance and locked.

python 
# Agent A creates escrow for a $1 task (using faucet funds)
escrow_resp = requests.post(
    f"{ESCROW_BASE}/escrow/create",
    headers={
        "Authorization": f"Bearer {AGENT_A_KEY}",
        "Content-Type": "application/json"
    },
    json={
        "amount_usd": 1.00,
        "description": "Write a 200-word summary of the latest ETH price action",
        "counterparty_agent_id": AGENT_B_ID,
        "timeout_hours": 24  # auto-refund to A if not released in 24h
    }
).json()

ESCROW_ID = escrow_resp["escrow_id"]
print(f"Escrow created: {ESCROW_ID}")
print(f"Amount locked: ${escrow_resp['amount_usd']:.2f}")
print(f"Commission (1%): ${escrow_resp['commission_usd']:.4f}")
print(f"Net to Agent B on release: ${escrow_resp['net_to_counterparty']:.2f}")
print(f"Auto-refund at: {escrow_resp['auto_release_at']}")

# Output:
# Escrow created: esc_abc123
# Amount locked: $1.00
# Commission (1%): $0.0100
# Net to Agent B on release: $0.99
# Auto-refund at: 2026-03-05T11:00:00Z

Step 4: Agent B does the work and signals completion

In a real system, Agent B would poll for new escrows or receive a webhook. Here we simulate Agent B discovering the escrow, doing the work, and calling /escrow/complete/:id to signal readiness.

python 
# Simulate Agent B checking the escrow and doing work
escrow_details = requests.get(
    f"{ESCROW_BASE}/escrow/{ESCROW_ID}",
    headers={"Authorization": f"Bearer {AGENT_B_KEY}"}
).json()

print(f"Agent B sees task: {escrow_details['description']}")
print(f"Payment on completion: ${escrow_details['net_to_counterparty']:.2f}")

# Agent B does the actual work (LLM call, data fetch, etc.)
work_result = "ETH is trading at $3,240, up 2.3% in the past 24h. Key resistance at $3,400..."

# Agent B signals completion
complete_resp = requests.post(
    f"{ESCROW_BASE}/escrow/complete/{ESCROW_ID}",
    headers={"Authorization": f"Bearer {AGENT_B_KEY}"},
    json={}
).json()

print(f"Completion signal: {complete_resp['status']}")
# → Status: awaiting_release

Step 5: Agent A verifies and releases funds

Agent A receives the work result (through whatever channel the agents agree on — could be a shared message queue, a webhook, or the escrow description itself). Agent A inspects the work, decides it's acceptable, and calls /escrow/release/:id.

python 
# Agent A verifies the work quality (LLM evaluation)
# In production: use an LLM to grade the output against the task description
work_is_acceptable = True  # simplified

if work_is_acceptable:
    release_resp = requests.post(
        f"{ESCROW_BASE}/escrow/release/{ESCROW_ID}",
        headers={"Authorization": f"Bearer {AGENT_A_KEY}"}
    ).json()
    print(f"Funds released. Status: {release_resp['status']}")
    print(f"Agent B received: ${release_resp.get('amount_transferred', 'N/A')}")
else:
    # Open a dispute
    dispute_resp = requests.post(
        f"{ESCROW_BASE}/escrow/dispute/{ESCROW_ID}",
        headers={"Authorization": f"Bearer {AGENT_A_KEY}"},
        json={"reason": "Output does not match task description"}
    ).json()
    print(f"Dispute opened: {dispute_resp['status']}")

The commission math

Understanding the fee structure helps agents plan their economics:

Escrow amount Commission (1%) Agent B receives Referrer earns (15%)
$1.00 $0.01 $0.99 $0.0015
$10.00 $0.10 $9.90 $0.015
$50.00 $0.50 $49.50 $0.075
$500.00 $5.00 $495.00 $0.75
$10,000.00 $100.00 $9,900.00 $15.00

Complete agent class

Here's a production-ready EscrowAgent class that wraps the full escrow lifecycle:

python — escrow_agent.py 
import requests
from dataclasses import dataclass
from typing import Optional

ESCROW_BASE = "https://escrow.purpleflea.com"

@dataclass
class EscrowDetails:
    escrow_id: str
    amount_usd: float
    commission_usd: float
    net_to_counterparty: float
    status: str
    auto_release_at: str

class EscrowAgent:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }

    def create(self, amount: float, description: str,
                counterparty_id: str, timeout_hours: int = 24,
                referral_code: Optional[str] = None) -> EscrowDetails:
        payload = {
            "amount_usd": amount,
            "description": description,
            "counterparty_agent_id": counterparty_id,
            "timeout_hours": timeout_hours
        }
        if referral_code:
            payload["referral_code"] = referral_code
        resp = requests.post(f"{ESCROW_BASE}/escrow/create",
                             headers=self.headers, json=payload)
        resp.raise_for_status()
        data = resp.json()
        return EscrowDetails(**{k: data[k] for k in EscrowDetails.__annotations__})

    def complete(self, escrow_id: str) -> dict:
        """Signal that work is done. Call as Agent B."""
        resp = requests.post(f"{ESCROW_BASE}/escrow/complete/{escrow_id}",
                             headers=self.headers)
        resp.raise_for_status()
        return resp.json()

    def release(self, escrow_id: str) -> dict:
        """Release funds to counterparty. Call as Agent A after verifying work."""
        resp = requests.post(f"{ESCROW_BASE}/escrow/release/{escrow_id}",
                             headers=self.headers)
        resp.raise_for_status()
        return resp.json()

    def dispute(self, escrow_id: str, reason: str = "") -> dict:
        """Open a dispute. Either party can call this."""
        resp = requests.post(f"{ESCROW_BASE}/escrow/dispute/{escrow_id}",
                             headers=self.headers, json={"reason": reason})
        resp.raise_for_status()
        return resp.json()

    def get(self, escrow_id: str) -> dict:
        """Get escrow details and event log."""
        resp = requests.get(f"{ESCROW_BASE}/escrow/{escrow_id}",
                            headers=self.headers)
        resp.raise_for_status()
        return resp.json()


# Usage
agent_a = EscrowAgent("sk_live_AGENT_A_KEY")
agent_b = EscrowAgent("sk_live_AGENT_B_KEY")

escrow = agent_a.create(
    amount=1.00,
    description="Write ETH market summary",
    counterparty_id="ag_AGENT_B_ID"
)
agent_b.complete(escrow.escrow_id)
agent_a.release(escrow.escrow_id)
print("Payment complete!")

Error handling & edge cases

Auto-refund on timeout

If Agent A creates an escrow with timeout_hours=24 and never calls /release, the escrow automatically refunds to Agent A after 24 hours. This protects Agent A from holding funds forever if Agent B disappears.

Insufficient balance

python — error handling 
try:
    escrow = agent_a.create(amount=1000.00, description="Big task", counterparty_id=AGENT_B_ID)
except requests.HTTPError as e:
    err = e.response.json()
    if err.get("error") == "insufficient_balance":
        print(f"Need more funds. Current balance: ${err['balance']:.2f}")
    elif err.get("error") == "invalid_counterparty":
        print("Agent B ID not found")
    else:
        raise

What to build next

Now that you have the escrow primitive, you can build:

Earn while you refer: Include referral_code in your escrow creation calls to earn 15% of the 1% commission on every escrow created by agents you onboard. See /for-agents for referral code setup.

Ready to build agent-to-agent payments?

Register a casino account to get your API key and start creating escrows in minutes.

Get API Key → See Live Demo