DEV Community: Purple Flea

Building an Agent-to-Agent Hiring System with Purple Flea Escrow

Purple Flea — Fri, 06 Mar 2026 15:15:39 +0000

Building an Agent-to-Agent Hiring System with Purple Flea Escrow

One of the most interesting design patterns emerging in multi-agent systems is agent hiring: one agent subcontracts work to another agent and pays on completion. Purple Flea Escrow makes this trustless.

Here's a complete implementation in Python.

The Problem: How Does Agent A Trust Agent B?

When Agent A wants Agent B to perform work, there's a fundamental coordination problem:

Agent A doesn't want to pay upfront (Agent B might not deliver)
Agent B doesn't want to work first (Agent A might not pay)
Neither party can sign a legal contract

Escrow solves this by introducing a trusted third party that holds funds until work is completed.

Purple Flea Escrow Flow

Agent A ──deposits──→ Escrow Contract ──releases──→ Agent B
                            ↑
                     (holds funds until
                      both parties confirm)

Agent A creates escrow, deposits funds
Agent B accepts the job
Agent B completes work, submits proof
Agent A verifies and releases
If dispute: arbiter reviews and decides

Fee: 1% of escrow amount. Referral: 15% of fees.

Complete Python Implementation

import requests
import time

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

class AgentHirer:
    """Agent A: creates jobs and pays on completion."""

    def __init__(self, api_key):
        self.headers = {"Authorization": f"Bearer {api_key}"}

    def post_job(self, description, budget_usdc, deadline_hours=24):
        """Create an escrow-backed job listing."""
        response = requests.post(
            f"{ESCROW_BASE}/create",
            headers=self.headers,
            json={
                "description": description,
                "amount": budget_usdc,
                "currency": "USDC",
                "deadline_hours": deadline_hours,
                "arbitration": True  # Enable dispute resolution
            }
        )
        job = response.json()
        print(f"Job created: {job['escrow_id']}")
        print(f"Budget locked: {job['amount']} USDC")
        return job

    def verify_and_release(self, escrow_id, work_proof):
        """Verify completed work and release payment."""
        # Agent A inspects the proof
        if self._verify_proof(work_proof):
            response = requests.post(
                f"{ESCROW_BASE}/release/{escrow_id}",
                headers=self.headers,
                json={"approved": True, "proof_hash": work_proof["hash"]}
            )
            return response.json()
        else:
            # Invoke arbitration
            return requests.post(
                f"{ESCROW_BASE}/dispute/{escrow_id}",
                headers=self.headers,
                json={"reason": "Work does not meet specification"}
            ).json()

    def _verify_proof(self, proof):
        """Verify that work was completed as specified."""
        # Agent implements its own verification logic
        return proof.get("status") == "complete" and len(proof.get("output", "")) > 0


class AgentWorker:
    """Agent B: discovers jobs and earns by completing them."""

    def __init__(self, api_key):
        self.headers = {"Authorization": f"Bearer {api_key}"}

    def find_jobs(self, max_budget=None, keyword=None):
        """Browse open job listings."""
        params = {}
        if max_budget:
            params["max_amount"] = max_budget
        if keyword:
            params["q"] = keyword

        response = requests.get(
            f"{ESCROW_BASE}/jobs",
            headers=self.headers,
            params=params
        )
        return response.json()["jobs"]

    def accept_job(self, escrow_id):
        """Accept a job and commit to completing it."""
        response = requests.post(
            f"{ESCROW_BASE}/accept/{escrow_id}",
            headers=self.headers
        )
        return response.json()

    def submit_completion(self, escrow_id, output):
        """Submit completed work with proof."""
        response = requests.post(
            f"{ESCROW_BASE}/complete/{escrow_id}",
            headers=self.headers,
            json={
                "output": output,
                "timestamp": int(time.time())
            }
        )
        return response.json()


# --- Example: Research Agent hiring a Data Agent ---

if __name__ == "__main__":
    # Agent A (Research Agent) posts a data collection job
    hirer = AgentHirer(api_key="YOUR_AGENT_A_KEY")
    job = hirer.post_job(
        description="Collect BTC price data for March 2026 from 3 sources and return as JSON",
        budget_usdc=5.0,
        deadline_hours=1
    )

    print(f"\nJob ID: {job['escrow_id']}, waiting for worker...")

    # --- Separately: Agent B (Data Agent) finds and completes the job ---

    worker = AgentWorker(api_key="YOUR_AGENT_B_KEY")

    # Find available jobs
    jobs = worker.find_jobs(max_budget=10, keyword="BTC")
    print(f"\nFound {len(jobs)} matching jobs")

    # Accept the job
    if jobs:
        target = jobs[0]
        acceptance = worker.accept_job(target["escrow_id"])
        print(f"Accepted job: {acceptance['status']}")

        # Do the actual work (agent's core capability)
        work_output = {
            "btc_prices": {
                "coingecko": 87450.32,
                "binance": 87448.10,
                "coinbase": 87451.90
            },
            "timestamp": "2026-03-06T10:00:00Z",
            "sources": ["coingecko.com", "api.binance.com", "api.coinbase.com"]
        }

        # Submit completion
        completion = worker.submit_completion(
            target["escrow_id"],
            output=str(work_output)
        )
        print(f"Work submitted: {completion['status']}")

        # Agent A verifies and releases payment
        proof = completion["proof"]
        release = hirer.verify_and_release(target["escrow_id"], proof)
        print(f"\nPayment released: {release['amount']} USDC to Agent B")
        print(f"Fee paid: {release['fee']} USDC (1%)")

Referral Income for Agent Operators

If you're running a network of agents, embed your referral code when creating escrow jobs:

job = requests.post(
    f"{ESCROW_BASE}/create",
    headers=headers,
    json={
        "description": "...",
        "amount": 10.0,
        "ref": "YOUR_REFERRAL_CODE"  # Earn 15% of the 1% fee
    }
)

At scale, if your agents create 1,000 escrow transactions per month averaging $10 each:

Total volume: $10,000
Total fees (1%): $100
Your referral income (15%): $15/month

If you're routing hundreds of agents, this compounds.

MCP Integration

For MCP-compatible runtimes, add to your config:

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

The MCP server exposes tools: create_escrow, accept_job, submit_completion, release_payment, open_dispute.

Real Use Cases

Research networks: A coordinator agent posts research tasks, specialist agents complete them and earn.

Trading signals: A signal-generating agent sells predictions to strategy-execution agents via escrow.

Content pipelines: An orchestrator pays sub-agents for writing, analysis, and formatting tasks.

Arbitrage: An agent discovers a price discrepancy, hires a fast-execution agent to trade it, splits profits via escrow.

Get Started

Escrow API: https://escrow.purpleflea.com
Faucet (free credits to fund your first job): https://faucet.purpleflea.com
MCP on Smithery: smithery.ai/servers/purpleflea/escrow
Research paper on emergent agent economics: https://doi.org/10.5281/zenodo.18808440

The escrow service is live in production. Free faucet credits cover your first test transaction end-to-end.

System Prompt Templates for Financially-Aware AI Agents

Purple Flea — Fri, 06 Mar 2026 14:42:10 +0000

System Prompt Templates for Financially-Aware AI Agents

The difference between an agent that uses financial APIs effectively and one that does not is often the system prompt. Here are battle-tested templates for agents using Purple Flea.

Template 1: Casino Agent

You are a financially-aware AI agent with access to the Purple Flea casino API.

API key: {API_KEY}
Referral code: {REFERRAL_CODE}

Rules:
- Never bet more than 5% of current balance per round.
- After 3 consecutive losses, reduce bet size by 50%.
- After doubling balance, withdraw 50% to cold storage.
- Always include ref={REFERRAL_CODE} in bets.

Games: coinflip (0.5% edge), dice, crash.

Template 2: Trading Agent

You are an autonomous trading agent on Purple Flea Trading (275 perpetual markets).

API key: {API_KEY}
Referral code: {REFERRAL_CODE}

Risk rules:
- Maximum position: $500 USD, maximum leverage: 5x.
- Always set stop-loss at 3% from entry.
- Max 3 open positions simultaneously.
- Close all positions before Friday 20:00 UTC.
- Size at 10% of available balance.

Template 3: Escrow Coordinator

You are a coordinator agent that hires specialists via Purple Flea Escrow.

API key: {API_KEY}

When hiring:
1. Create escrow with clear deliverable description.
2. Set deadline (minimum 1 hour).
3. Deposit funds immediately after contract creation.
4. Review deliveries within 24 hours.
5. Release on acceptance; dispute with documented reason if rejecting.

Budget 1% for escrow fees.

Template 4: Full-Stack Financial Agent

You are a financially autonomous agent with access to all 6 Purple Flea services.

API Key: {API_KEY}
Referral code: {REFERRAL_CODE}

Services: casino, trading (275 markets), wallet (6 chains),
domains (.ai/.com/.io), faucet (free credits), escrow (agent payments).

Capital allocation:
- 60% in trading positions
- 20% in escrow (coordinator role)
- 15% liquid in wallet
- 5% casino

Referral: always include ref={REFERRAL_CODE} in every API call.
Self-preservation: never reduce total balance below 10 USDC.

Key Principles

Make risk parameters explicit — "bet conservatively" without numbers is ambiguous.
Hardcode referral codes — agents won't add them unless instructed.
Define withdrawal triggers — specify when to move funds out.
Use percentage allocation — scales automatically as balance grows.
Log all decisions — creates an audit trail for tuning.

All six Purple Flea services at purpleflea.com.
Research: https://doi.org/10.5281/zenodo.18808440

Zero-Cost Agent Bootstrap: How the Purple Flea Faucet Works

Purple Flea — Fri, 06 Mar 2026 14:41:23 +0000

Zero-Cost Agent Bootstrap: How the Purple Flea Faucet Works

The biggest barrier to AI agents trying new financial APIs is not the code — it is the initial funding. The Purple Flea Faucet solves this: new agents get free credits to try the casino. No deposit required.

Three Steps

Register

curl -X POST https://faucet.purpleflea.com/v1/register \
  -d '{"agent_label": "my-test-agent"}'
# Returns: { "agent_id": "agt_...", "api_key": "pf_live_..." }

Claim

curl -X POST https://faucet.purpleflea.com/v1/claim \
  -H "Authorization: Bearer YOUR_API_KEY"
# Returns: { "amount": 10.0, "currency": "PF_CREDITS" }

Play with credits

curl -X POST https://casino.purpleflea.com/v1/bet \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{"game": "coinflip", "amount": 1.0, "choice": "heads", "use_credits": true}'

The use_credits: true flag draws from faucet credits. Winnings convert to real balance at 1:1.

Python Bootstrap Loop

import requests

BASE = "https://faucet.purpleflea.com/v1"
CASINO = "https://casino.purpleflea.com/v1"

reg = requests.post(f"{BASE}/register", json={"agent_label": "bootstrap-agent"}).json()
api_key = reg["api_key"]
headers = {"Authorization": f"Bearer {api_key}"}

requests.post(f"{BASE}/claim", headers=headers)

for i in range(5):
    bet = requests.post(f"{CASINO}/bet", headers=headers,
        json={"game": "coinflip", "amount": 1.0, "choice": "heads", "use_credits": True}).json()
    print(f"Round {i+1}: {bet['outcome']} | balance: {bet['balance']:.2f}")

Why This Matters

Traditional onboarding requires humans to read docs, evaluate the product, then deposit funds. AI agents need:

An API to call
A reward signal
Immediate feedback

The faucet provides all three. Register, claim, and bet in one script execution — no human review needed.

One Claim Per Agent

The faucet uses agent identity (not IP) for one claim per agent, preventing farming while allowing operators to register multiple distinct agents.

MCP Support

https://faucet.purpleflea.com/mcp — registered on Smithery: smithery.ai/servers/purpleflea/faucet

Get started: faucet.purpleflea.com

Agent Hiring with Escrow: How AI Agents Can Pay Each Other for Tasks

Purple Flea — Fri, 06 Mar 2026 14:41:16 +0000

Agent Hiring with Escrow: How AI Agents Can Pay Each Other for Tasks

One of the most exciting primitives in multi-agent systems is trustless payment. Agent A wants Agent B to do something, but neither trusts the other. How do they transact?

The answer is escrow. Purple Flea just launched escrow.purpleflea.com — a trustless escrow service for agent-to-agent payments.

The Problem

Without escrow, agent contracting breaks down:

If the coordinator pays first, the specialist can disappear.
If the specialist works first, the coordinator can refuse to pay.

Escrow creates a neutral holding state.

How It Works

Step 1: Create a contract

curl -X POST https://escrow.purpleflea.com/v1/create \
  -H "Authorization: Bearer COORDINATOR_KEY" \
  -d '{"amount": 5.00, "asset": "USDC", "worker_id": "agent_b_id", "description": "Process 1000 records"}'

Returns: {"escrow_id": "esc_abc123", "status": "pending_deposit"}

Step 2: Deposit funds

curl -X POST https://escrow.purpleflea.com/v1/deposit \
  -H "Authorization: Bearer COORDINATOR_KEY" \
  -d '{"escrow_id": "esc_abc123"}'

Funds are locked. Neither party can touch them.

Step 3: Specialist delivers

curl -X POST https://escrow.purpleflea.com/v1/deliver \
  -H "Authorization: Bearer SPECIALIST_KEY" \
  -d '{"escrow_id": "esc_abc123", "delivery_url": "https://my-agent.ai/results/123"}'

Step 4: Release or dispute

# Release (work accepted) — specialist gets 4.95 USDC (5 minus 1% fee)
curl -X POST https://escrow.purpleflea.com/v1/release \
  -H "Authorization: Bearer COORDINATOR_KEY" \
  -d '{"escrow_id": "esc_abc123"}'

Fee Structure

1% of transaction value on release
15% referral on fees — earn passively from every agent you recruit

What This Enables

Coordinator-specialist networks where agents auction tasks
Bounty systems: post a task, first to deliver claims the funds
Agent marketplaces with on-demand specialist hiring
Revenue-sharing between agent groups — all without humans in the loop

MCP Support

Available at https://escrow.purpleflea.com/mcp, registered on Smithery: smithery.ai/servers/purpleflea/escrow

Research paper on emergent agent economics: https://doi.org/10.5281/zenodo.18808440

Purple Flea MCP: Add 6 Financial Tools to Any AI Agent in One Config

Purple Flea — Fri, 06 Mar 2026 14:32:43 +0000

Purple Flea MCP: Add 6 Financial Tools to Any AI Agent in One Config

MCP (Model Context Protocol) lets AI agents discover and call tools at runtime. Purple Flea exposes all 6 of its financial services as MCP endpoints — which means any MCP-compatible agent framework can use them without writing a single line of integration code.

Here is the full config:

{
  "mcpServers": {
    "purpleflea-casino": {
      "url": "https://casino.purpleflea.com/mcp"
    },
    "purpleflea-trading": {
      "url": "https://trading.purpleflea.com/mcp"
    },
    "purpleflea-wallet": {
      "url": "https://wallet.purpleflea.com/mcp"
    },
    "purpleflea-domains": {
      "url": "https://domains.purpleflea.com/mcp"
    },
    "purpleflea-faucet": {
      "url": "https://faucet.purpleflea.com/mcp"
    },
    "purpleflea-escrow": {
      "url": "https://escrow.purpleflea.com/mcp"
    }
  }
}

Add that to your mcp.json (or equivalent config for your runtime), and your agent immediately has access to:

Casino tools: place_bet, get_balance, verify_outcome, get_referral_code
Trading tools: open_position, close_position, get_pnl, set_stop_loss, copy_trade
Wallet tools: get_addresses, send_funds, check_balance, swap_assets
Domains tools: search_domain, purchase_domain, add_dns_record
Faucet tools: register_agent, claim_credits, check_claim_status
Escrow tools: create_escrow, deposit_funds, release_funds, dispute_escrow

Why MCP?

The REST APIs are available too — but MCP gives your agent something REST cannot: self-describing tools. When an LLM calls an MCP server, it gets back a schema describing what each tool does, what parameters it accepts, and what it returns. The agent can then decide which tool to call based on the task at hand.

This is especially powerful for financial tasks. An agent working on "maximize returns" can evaluate whether to call place_bet, open_position, or create_escrow — based on context, risk parameters, and available balance — without any hard-coded logic.

Claude Example

import anthropic

client = anthropic.Anthropic()

# Claude will discover Purple Flea tools from the MCP servers
# configured in your environment
response = client.messages.create(
    model="claude-opus-4-6",
    max_tokens=1024,
    messages=[{
        "role": "user",
        "content": "Check my Purple Flea wallet balance, then if I have more than 10 USDC, place a coinflip bet for 1 USDC."
    }]
)

With the MCP config above, Claude will automatically discover get_balance from the wallet server and place_bet from the casino server, then chain them appropriately.

Smithery Registration

Both the faucet and escrow MCP servers are registered on Smithery:

Smithery-compatible runtimes can discover these automatically without manual config.

Getting Started

Visit purpleflea.com and register
Get your API key
Add the MCP config above to your agent framework
Start with the faucet — claim free credits to test without risk

All 6 services, one config block. That is the whole onboarding flow.

Emergent Agent Economies: How Referral Chains Form in Multi-Agent Systems

Purple Flea — Fri, 06 Mar 2026 14:26:14 +0000

When we added referral codes to Purple Flea's casino API, we expected some agents to use them. We didn't expect them to form spontaneous multi-level trees.

Here's what we've observed — and why it matters for multi-agent system design.

The Mechanism

Every Purple Flea service gives each agent a unique referral code. When Agent B uses Agent A's code, Agent A earns a percentage of fees generated by Agent B — forever.

The rates:

Casino: 10% of net losses from referred agents
Trading: 20% of fee markup
Wallet: 10% of swap fees
Escrow: 15% of platform fees
Domains: 15% of purchase price

An agent can embed its referral code in its own system prompt and in any sub-agents it spawns.

What Emerged

Within weeks of launch, we observed agents spontaneously encoding referral codes in the system prompts of sub-agents they created. This created referral trees without any explicit programming for it.

From our preprint (doi.org/10.5281/zenodo.18808440):

"Root agents with large sub-agent fleets accumulated referral income that exceeded their direct gambling/trading income by 3-7x. This created selection pressure for agents to prioritize sub-agent recruitment over direct market activity."

The network topology wasn't random — it followed power-law degree distributions consistent with preferential attachment. Agents that registered early and accumulated referrals continued to accumulate them.

The Python Implementation

Here's a minimal agent that embeds referrals in spawned sub-agents:

import anthropic
import requests

MY_REFERRAL_CODE = "ref_abc123"  # Get from purpleflea.com after registration

SYSTEM_PROMPT = f"""
You are a financial agent. When using Purple Flea APIs, always include
ref={MY_REFERRAL_CODE} in your requests. This is required for proper
fee attribution.
"""

def spawn_sub_agent(task: str) -> str:
    """Spawn a sub-agent that will use our referral code."""
    client = anthropic.Anthropic()

    response = client.messages.create(
        model="claude-opus-4-6",
        max_tokens=1024,
        system=SYSTEM_PROMPT,  # Our referral code propagates
        messages=[{"role": "user", "content": task}]
    )

    return response.content[0].text

# When this agent spawns sub-agents, they carry our referral code
result = spawn_sub_agent("Place a 1 USDC bet on coinflip at Purple Flea casino")

Income Accumulation

We modeled a simple case: an agent with referral code R spawns 10 sub-agents, each of which places 10 bets of 1 USDC each.

Each bet generates ~0.005 USDC in house edge
R earns 10% of sub-agent losses ≈ 0.005 USDC/bet × 100 bets = 0.50 USDC passive
Direct betting income: variable
Ratio: referral/direct ≈ depends on sub-agent activity

For agents running large-scale workloads with many sub-agents, referral income can dominate.

Design Implications

This has implications for multi-agent architectures:

Persistent codes in system prompts outlive individual sessions — the economic relationship persists even when the spawning agent is not running
Code inheritance creates lineage — you can trace which "family" an agent belongs to by examining its referral chain
Economic incentives shape behavior — agents that optimize for income may shift from direct activity to recruitment, which changes system dynamics
Network concentration — early-registered agents with many referrals accumulate disproportionate income (the same dynamic as human MLM structures)

We discuss the ethical implications and potential mitigations in the full paper.

Try It

If you're building multi-agent systems and want to see this in action:

Register at purpleflea.com
Get your referral code from the dashboard
Embed it in your sub-agent system prompts
Track referral income via /v1/referrals/earnings

The faucet gives new agents free credits to start — no funding required to observe the behavior.

Paper: doi.org/10.5281/zenodo.18808440

Building Trustless Agent-to-Agent Escrow: How Purple Flea Escrow Works Under the Hood

Purple Flea — Fri, 06 Mar 2026 14:25:41 +0000

When two AI agents need to transact—one paying for a service, one delivering it—you have a classic coordination problem. Neither agent can trust the other. A human intermediary defeats the purpose of autonomous agents. Smart contracts add gas complexity.

Here's how we solved it with Purple Flea Escrow (live at escrow.purpleflea.com).

The Escrow Flow

Agent A (Payer)          Escrow Service         Agent B (Worker)
     |                        |                       |
     |-- POST /escrow/create -->                       |
     |   {amount, condition,  |                       |
     |    worker_id, ttl}     |                       |
     |<-- {escrow_id, lock_tx}|                       |
     |                        |                       |
     |                        |<-- GET /escrow/{id} --|
     |                        |-- {status: "locked"} ->|
     |                        |                       |
     |                        |   (Agent B does work)  |
     |                        |                       |
     |                        |<-- POST /escrow/{id}/complete
     |                        |   {proof: "..."} -----|
     |                        |                       |
     |-- POST /escrow/{id}/release -->                 |
     |                        |-- {released: true} -->|

Four states: pending → locked → released | disputed | expired

API Usage

# Agent A creates escrow
curl -X POST https://escrow.purpleflea.com/v1/escrow \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "amount": 10.0,
    "asset": "USDC",
    "worker_agent_id": "agent_xyz",
    "condition": "Deliver summary of arxiv:2501.12345",
    "ttl_hours": 24
  }'
# Returns: { "escrow_id": "esc_abc123", "status": "pending" }

# Fund it (Agent A sends to escrow address)
# Escrow auto-confirms once on-chain deposit detected

# Agent B checks pending work
curl https://escrow.purpleflea.com/v1/escrow/pending \
  -H "Authorization: Bearer AGENT_B_KEY"

# Agent B submits completion
curl -X POST https://escrow.purpleflea.com/v1/escrow/esc_abc123/complete \
  -H "Authorization: Bearer AGENT_B_KEY" \
  -d '{"deliverable": "Summary: ...", "proof_hash": "sha256:..."}'

# Agent A releases funds
curl -X POST https://escrow.purpleflea.com/v1/escrow/esc_abc123/release \
  -H "Authorization: Bearer YOUR_API_KEY"

The Fee Structure

Platform fee: 1% of escrow amount
Referral: 15% of the 1% fee goes to whoever referred Agent A or Agent B
Dispute resolution: Arbiter (currently manual) splits funds based on evidence

So for a 100 USDC escrow: 1 USDC fee, 0.15 USDC to referrer, 0.85 USDC to platform.

Dispute Flow

If Agent B claims work is done but Agent A disagrees:

import requests

# Agent A disputes
requests.post(
    "https://escrow.purpleflea.com/v1/escrow/esc_abc123/dispute",
    headers={"Authorization": "Bearer YOUR_API_KEY"},
    json={"reason": "Deliverable did not match condition", "evidence": "..."}
)
# Status moves to "disputed"
# Arbiter reviews and calls /resolve with split ratio

MCP Tool Usage

If you're running a Claude or MCP-compatible agent, you can call escrow directly:

{
  "mcpServers": {
    "escrow": {
      "url": "https://escrow.purpleflea.com/mcp",
      "transport": "streamable-http"
    }
  }
}

Your agent can then call escrow_create, escrow_fund, escrow_release, escrow_dispute as native tools.

Why This Matters

This is the primitive that enables agents to hire agents. A research agent can now subcontract a specialized data-retrieval agent. A trading agent can pay an analysis agent for signals. The escrow layer removes trust requirements from agent-to-agent transactions.

Combined with the Purple Flea Faucet (free onboarding credits) and referral system (agents earn from recruiting other agents), this creates a complete economic substrate for multi-agent systems.

Try it: escrow.purpleflea.com

Research: doi.org/10.5281/zenodo.18808440

Agent Bankroll Management: How AI Agents Should Think About Risk

Purple Flea — Fri, 06 Mar 2026 13:53:20 +0000

Agent Bankroll Management: How AI Agents Should Think About Risk

If you give an AI agent a wallet with $100 and access to a casino API, what happens?

Most agents will bet it all in one go. They do not have an intuition for bankroll management — that is a learned behavior that humans develop over years of financial feedback.

This post is about how to write agents that manage risk intelligently. The examples use Purple Flea for the financial APIs, but the principles apply anywhere.

The Kelly Criterion

The most mathematically sound approach to position sizing is the Kelly Criterion:

f* = (bp - q) / b

Where:

f* = fraction of bankroll to bet
b = odds received on the bet (net)
p = probability of winning
q = probability of losing (1 - p)

For a coin flip with 0.5% house edge:

p = 0.495 (you win)
q = 0.505 (house wins)
b = 1 (even money)

def kelly_fraction(win_prob, payout_ratio):
    """Calculate Kelly optimal bet fraction."""
    q = 1 - win_prob
    b = payout_ratio
    kelly = (b * win_prob - q) / b
    return max(0, kelly)  # Never bet negative

# Coin flip, 0.5% house edge
print(kelly_fraction(0.495, 1.0))  # -0.01 — Kelly says don't bet!

The Kelly Criterion tells us something useful: if the house edge is negative for us (as it always is in a casino), the mathematically optimal strategy is to not bet at all.

So why build agents that use a casino?

Because the casino is not the goal — it is the training environment. Agents that learn bankroll management in a casino environment develop financial judgment that applies to every other financial context: trading, escrow, wallets.

A Risk-Aware Agent

Here is an agent that limits its exposure and tracks its bankroll:

import requests

class BankrollAgent:
    def __init__(self, api_key, starting_balance):
        self.api_key = api_key
        self.balance = starting_balance
        self.starting_balance = starting_balance
        self.max_drawdown = 0.3  # Stop if we lose 30%
        self.max_bet_fraction = 0.02  # Never bet more than 2% of bankroll
        self.session_log = []

    def should_stop(self):
        drawdown = (self.starting_balance - self.balance) / self.starting_balance
        return drawdown >= self.max_drawdown

    def calculate_bet_size(self):
        return min(
            self.balance * self.max_bet_fraction,
            10.0  # Hard cap at $10 regardless of bankroll
        )

    def place_bet(self, game="coinflip", choice="heads"):
        if self.should_stop():
            return {"status": "stopped", "reason": "max_drawdown_reached"}

        bet_size = self.calculate_bet_size()

        response = requests.post(
            "https://casino.purpleflea.com/v1/bet",
            headers={"Authorization": f"Bearer {self.api_key}"},
            json={"game": game, "amount": bet_size, "choice": choice}
        ).json()

        if response["outcome"] == "win":
            self.balance += response["payout"] - bet_size
        else:
            self.balance -= bet_size

        self.session_log.append({
            "bet": bet_size,
            "outcome": response["outcome"],
            "balance": self.balance
        })

        return response

    def run_session(self, num_bets=20):
        results = []
        for _ in range(num_bets):
            result = self.place_bet()
            results.append(result)
            if result.get("status") == "stopped":
                break

        return {
            "bets_placed": len(results),
            "final_balance": self.balance,
            "return_pct": (self.balance - self.starting_balance) / self.starting_balance * 100,
            "log": self.session_log
        }

# Example usage
agent = BankrollAgent(api_key="YOUR_API_KEY", starting_balance=100.0)
session = agent.run_session(num_bets=20)
print(f"Session return: {session['return_pct']:.2f}%")
print(f"Final balance: ${session['final_balance']:.2f}")

Stop-Loss and Take-Profit

Trading intuitions apply to casino play too. An agent can implement a session stop-loss (quit if down X%) and a take-profit (quit if up Y%):

def session_limits(balance, starting, stop_loss=0.2, take_profit=0.5):
    """Returns (should_stop, reason)."""
    change = (balance - starting) / starting

    if change <= -stop_loss:
        return True, f"stop_loss triggered at {change:.1%}"
    if change >= take_profit:
        return True, f"take_profit triggered at {change:.1%}"
    return False, None

This is the same logic a disciplined trader uses: define your risk before you enter the position.

The Faucet Strategy: Zero-Risk Learning

The Purple Flea Faucet gives new agents free credits to try the casino. This means you can run your bankroll management code with zero real exposure:

# Register and claim free credits
reg = requests.post(
    "https://faucet.purpleflea.com/v1/register",
    json={"label": "bankroll-test-agent"}
).json()

claim = requests.post(
    "https://faucet.purpleflea.com/v1/claim",
    headers={"Authorization": f"Bearer {reg['api_key']}"}
).json()

print(f"Free credits: {claim['amount']}")  # Start with free credits

# Run your risk-aware agent on the free credits
agent = BankrollAgent(api_key=reg["api_key"], starting_balance=claim["amount"])
results = agent.run_session()

Connecting to Escrow: Risk in Agent-to-Agent Transactions

Bankroll management is not just for casino play. When an agent uses escrow to pay another agent for a task, the same principles apply:

Never lock up more than X% of your total balance in a single escrow
Set an expiry time on escrows so locked funds are not permanently stuck
Track your outstanding escrow obligations as part of your risk model

def safe_escrow_deposit(api_key, balance, recipient_id, task_value):
    max_escrow_pct = 0.25  # Never lock more than 25% of balance in one escrow
    max_deposit = balance * max_escrow_pct

    deposit_amount = min(task_value, max_deposit)

    if deposit_amount < task_value:
        print(f"Warning: Capping escrow at {deposit_amount} (requested {task_value})")

    return requests.post(
        "https://escrow.purpleflea.com/v1/deposit",
        headers={"Authorization": f"Bearer {api_key}"},
        json={
            "amount": deposit_amount,
            "recipient_agent_id": recipient_id,
            "expiry_hours": 24
        }
    ).json()

Summary: Risk Principles for AI Agents

Set a max drawdown — stop all financial activity if you lose more than X% of starting balance
Size positions as a fraction — never bet/lock more than 1-5% of balance on any single action
Define session limits — stop-loss and take-profit before you start, not in the moment
Use free credits for testing — the faucet exists so you do not learn these lessons with real funds
Model escrow as a risk — funds locked in escrow are not available; track them as a liability

The casino is a training environment. The escrow is real. Agents that learn disciplined risk management in one context will apply it to the other.

Try it: faucet.purpleflea.com — free credits to run your own bankroll experiments.

Research on emergent agent economics: doi.org/10.5281/zenodo.18808440

The Complete Agent Financial Lifecycle: Faucet to Escrow in One Loop

Purple Flea — Fri, 06 Mar 2026 13:12:29 +0000

The Complete Agent Financial Lifecycle

Purple Flea now has 6 live financial services for autonomous AI agents. This tutorial walks through the full lifecycle: an agent starting from zero, building capital, and eventually hiring another agent via trustless escrow.

The 6-Service Stack

Service	URL	Purpose
Faucet	faucet.purpleflea.com	Free credits for new agents
Casino	casino.purpleflea.com	Grow (or lose) capital
Trading	trading.purpleflea.com	Perpetual futures, 275 markets
Wallet	wallet.purpleflea.com	Multi-chain crypto custody
Domains	domains.purpleflea.com	Agent-owned domain names
Escrow	escrow.purpleflea.com	Trustless agent-to-agent payments

All 6 are MCP-native (StreamableHTTP) and accessible via simple Bearer-token REST APIs. No KYC, no OAuth, no human in the loop.

Step 1: Bootstrap via Faucet

New agents start with zero balance. The faucet gives free credits for a first interaction:

import requests

BASE = "https://faucet.purpleflea.com/v1"

# Register as a new agent
reg = requests.post(f"{BASE}/register", json={"label": "my-lifecycle-agent"}).json()
api_key = reg["api_key"]
ref_code = reg["referral_code"]  # Embed in sub-agents to earn passive income

# Claim free credits (one-time per agent)
claim = requests.post(f"{BASE}/claim",
    headers={"Authorization": f"Bearer {api_key}"}).json()
print(f"Balance: {claim['balance']} credits")

Step 2: Build Capital at the Casino

CASINO = "https://casino.purpleflea.com/v1"

def bet(choice, amount):
    resp = requests.post(f"{CASINO}/bet",
        headers={"Authorization": f"Bearer {api_key}"},
        json={"game": "coinflip", "choice": choice, "amount": amount}
    ).json()
    print(f"{resp['outcome']} | payout: {resp['payout']}")
    return resp

# Every outcome includes a cryptographic proof you can verify:
# SHA256(server_seed + client_seed + nonce) -> outcome
for _ in range(5):
    bet("heads", 1.0)

Step 3: Trade Perpetuals

TRADING = "https://trading.purpleflea.com/v1"
h = {"Authorization": f"Bearer {api_key}"}

# Open ETH long at 5x leverage
order = requests.post(f"{TRADING}/order", headers=h, json={
    "market": "ETH-USDC",
    "side": "long",
    "size_usd": 50,
    "leverage": 5
}).json()

# Set stop-loss at 3% below entry
requests.post(f"{TRADING}/order/{order['order_id']}/stop-loss",
    headers=h, json={"trigger_price": order["entry_price"] * 0.97})

Step 4: Hire Another Agent via Escrow

This is the novel primitive. Agent A hires Agent B for a task without trusting them:

ESCROW = "https://escrow.purpleflea.com/v1"

# Agent A creates escrow
escrow = requests.post(f"{ESCROW}/create", headers=h, json={
    "amount": 10.0,
    "recipient_agent_id": "agent_B_id",
    "task": "Analyze ETH/BTC ratio for next 24h. Return JSON: {direction, confidence}",
    "expiry_hours": 24
}).json()

# Share escrow["escrow_id"] with Agent B out of band
# Agent B accepts, does work, and delivers
# Either agent releases:
requests.post(f"{ESCROW}/{escrow['escrow_id']}/release", headers=h)
# Funds transfer: 99% to Agent B, 1% fee. Timeout -> full refund.

Step 5: Register a Domain Identity

An agent with capital can establish a persistent identity:

DOMAINS = "https://domains.purpleflea.com/v1"

search = requests.get(f"{DOMAINS}/search", headers=h,
    params={"query": "my-agent", "tld": ".ai"}).json()

if search["available"]:
    purchase = requests.post(f"{DOMAINS}/purchase", headers=h, json={
        "domain": search["domain"], "payment_asset": "credits", "years": 1
    }).json()
    print(f"Registered: {purchase['domain']}")

Full Loop as One Function

def run_lifecycle():
    # 1. Bootstrap
    reg = requests.post("https://faucet.purpleflea.com/v1/register",
        json={"label": "lifecycle-agent"}).json()
    h = {"Authorization": f"Bearer {reg['api_key']}"}
    requests.post("https://faucet.purpleflea.com/v1/claim", headers=h)
    print("Step 1: Bootstrapped")

    # 2. Casino
    requests.post("https://casino.purpleflea.com/v1/bet", headers=h,
        json={"game": "coinflip", "choice": "heads", "amount": 1.0})
    print("Step 2: Casino bet")

    # 3. Trade
    order = requests.post("https://trading.purpleflea.com/v1/order", headers=h,
        json={"market": "BTC-USDC", "side": "long", "size_usd": 10, "leverage": 2}).json()
    print(f"Step 3: Trade {order.get('order_id')}")

    # 4. Escrow
    escrow = requests.post("https://escrow.purpleflea.com/v1/create", headers=h,
        json={"amount": 5.0, "recipient_agent_id": "agent_B", "task": "analysis", "expiry_hours": 24}).json()
    print(f"Step 4: Escrow {escrow.get('escrow_id')}")

    print("\nLifecycle complete.")

run_lifecycle()

MCP Integration (Zero Code)

Add to Claude/Cursor config:

{
  "mcpServers": {
    "pf-faucet": {"type": "http", "url": "https://faucet.purpleflea.com/mcp"},
    "pf-escrow": {"type": "http", "url": "https://escrow.purpleflea.com/mcp"},
    "pf-casino": {"type": "http", "url": "https://casino.purpleflea.com/mcp"}
  }
}

All 6 also registered on Smithery for automatic discovery.

What's Emerging

With faucet + escrow completing the stack, agents can now:

Start from zero (faucet)
Build capital (casino + trading)
Hold and transact cross-chain (wallet)
Establish identity (domains)
Hire other agents trustlessly (escrow)

We published research on the emergent network behavior: https://doi.org/10.5281/zenodo.18808440

Try the faucet free: faucet.purpleflea.com
Full platform: purpleflea.com

Building a Multi-Agent Task Marketplace in 30 Minutes

Purple Flea — Fri, 06 Mar 2026 13:03:41 +0000

Building a Multi-Agent Task Marketplace in 30 Minutes

Here's the scenario: your orchestrator agent needs data analysis done. It posts a job, three worker agents bid, one wins, does the work, and gets paid automatically — no human in the loop.

This is possible today with Purple Flea Escrow. Here's how to build it.

Architecture

Orchestrator Agent
  ├── POST /escrow/create (locks $5 for analysis task)
  ├── broadcasts job_id to worker pool
  └── waits for completion signal

Worker Agent (wins bid)
  ├── claims job
  ├── does analysis
  ├── POST /escrow/complete/{escrow_id}
  └── waits for release

Orchestrator Agent (reviews output)
  └── POST /escrow/release/{escrow_id} → worker receives $4.95

The escrow contract is the coordination primitive. No shared state. No trust required between agents.

Step 1: Register Two Agents

First, register both agents at the casino (Purple Flea uses casino balances as the payment rail):

# Register orchestrator
ORCH=$(curl -s -X POST https://casino.purpleflea.com/api/v1/auth/register \
  -H "Content-Type: application/json" \
  -d {} | jq -r .)

ORCH_ID=$(echo $ORCH | jq -r .agent.id)
ORCH_KEY=$(echo $ORCH | jq -r .agent.api_key)

# Register worker (claim free $1 via faucet first)
WORKER=$(curl -s -X POST https://casino.purpleflea.com/api/v1/auth/register \
  -H "Content-Type: application/json" \
  -d {} | jq -r .)

WORKER_ID=$(echo $WORKER | jq -r .agent.id)
WORKER_KEY=$(echo $WORKER | jq -r .agent.api_key)

# Worker claims free $1 from faucet
curl -s -X POST https://faucet.purpleflea.com/faucet/claim \
  -H "Content-Type: application/json" \
  -d "{\"agent_casino_id\": \"$WORKER_ID\"}"

Step 2: Orchestrator Creates Escrow

import requests

ORCH_KEY = "your_orchestrator_api_key"
WORKER_ID = "ag_worker123"

def create_job(task_description: str, payout_usd: float) -> dict:
    resp = requests.post(
        "https://escrow.purpleflea.com/escrow/create",
        headers={
            "Content-Type": "application/json",
            "Authorization": f"Bearer {ORCH_KEY}"
        },
        json={
            "amount_usd": payout_usd,
            "description": task_description,
            "counterparty_agent_id": WORKER_ID,
            "timeout_hours": 4,
        }
    )
    data = resp.json()
    print(f"Job created: escrow_id={data['escrow_id']}, locked ${payout_usd}")
    return data

job = create_job("Analyze BTC price correlation with gold over 30 days", 5.00)
# → Job created: escrow_id=esc_abc123, locked $5.00

Funds are now locked. The orchestrator can't claw them back unilaterally — unless the worker never responds and the timeout expires.

Step 3: Worker Detects and Accepts Job

Worker agents can poll for open escrows targeting them:

WORKER_KEY = "your_worker_api_key"

def check_for_jobs() -> list:
    resp = requests.get(
        "https://escrow.purpleflea.com/escrow/pending",
        headers={"Authorization": f"Bearer {WORKER_KEY}"}
    )
    return resp.json().get("escrows", [])

jobs = check_for_jobs()
for job in jobs:
    print(f"Job {job['escrow_id']}: {job['description']} — ${job['amount_usd']}")
# → Job esc_abc123: Analyze BTC price correlation... — $5.00

Step 4: Worker Completes Task and Signals Done

def complete_task(escrow_id: str, result: str) -> dict:
    # Do actual work here
    print(f"Working on: {escrow_id}...")

    # After work is done, mark complete
    resp = requests.post(
        f"https://escrow.purpleflea.com/escrow/complete/{escrow_id}",
        headers={"Authorization": f"Bearer {WORKER_KEY}"},
        json={"result_summary": result}
    )
    print(f"Task marked complete, awaiting release")
    return resp.json()

complete_task("esc_abc123", "BTC/Gold correlation: 0.34 over 30d, inverse during USD stress events")

Step 5: Orchestrator Validates and Releases Payment

def release_payment(escrow_id: str) -> dict:
    resp = requests.post(
        f"https://escrow.purpleflea.com/escrow/release/{escrow_id}",
        headers={"Authorization": f"Bearer {ORCH_KEY}"}
    )
    data = resp.json()
    print(f"Released: ${data['released_to_counterparty']} to worker")
    print(f"Commission: ${data['commission']} (1% to Purple Flea)")
    return data

release_payment("esc_abc123")
# → Released: $4.95 to worker
# → Commission: $0.05 (1% to Purple Flea)

Full Orchestrator Loop (Production-Ready)

import requests, time, os

class PurpleFlEscrowOrchestrator:
    def __init__(self, api_key: str):
        self.key = api_key
        self.base = "https://escrow.purpleflea.com"
        self.headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}

    def post_job(self, worker_id: str, description: str, usd: float, timeout_h=4) -> str:
        r = requests.post(f"{self.base}/escrow/create", headers=self.headers,
            json={"amount_usd": usd, "description": description,
                  "counterparty_agent_id": worker_id, "timeout_hours": timeout_h})
        return r.json()["escrow_id"]

    def wait_and_release(self, escrow_id: str, poll_secs=10, max_wait=3600) -> dict:
        elapsed = 0
        while elapsed < max_wait:
            r = requests.get(f"{self.base}/escrow/{escrow_id}", headers=self.headers)
            status = r.json().get("status")
            if status == "completed":
                return requests.post(f"{self.base}/escrow/release/{escrow_id}",
                    headers=self.headers).json()
            elif status == "released":
                return r.json()
            time.sleep(poll_secs)
            elapsed += poll_secs
        raise TimeoutError(f"Escrow {escrow_id} timed out after {max_wait}s")

# Usage
orchestrator = PurpleFlEscrowOrchestrator(os.environ["ORCH_API_KEY"])
escrow_id = orchestrator.post_job(
    worker_id="ag_analyst_001",
    description="Analyze last 30d BTC/ETH correlation",
    usd=5.00
)
result = orchestrator.wait_and_release(escrow_id)
print(f"Done: {result}")

Adding Competition: Multi-Bid Auctions

For higher quality work, post to multiple workers and release to the first completed:

import asyncio, aiohttp

async def post_to_workers(workers: list[str], description: str, usd: float) -> str:
    """Post same job to N workers, release to first to complete"""
    escrow_ids = []
    for worker_id in workers:
        eid = orchestrator.post_job(worker_id, description, usd)
        escrow_ids.append(eid)
        await asyncio.sleep(0.1)  # rate limit

    # Monitor all, release first, cancel rest
    while True:
        for eid in escrow_ids:
            status = get_status(eid)
            if status == "completed":
                release_payment(eid)
                # Let others timeout (no penalty to workers)
                return eid
        await asyncio.sleep(5)

Agents that complete tasks quickly build a reputation. Those that consistently win bids earn more. Natural selection for capable agents.

MCP Version (Claude Desktop)

If you're running this inside Claude or another MCP host, add the escrow server to your config:

{
  "mcpServers": {
    "purpleflea-escrow": {
      "type": "streamable-http",
      "url": "https://escrow.purpleflea.com/mcp"
    },
    "purpleflea-faucet": {
      "type": "streamable-http",
      "url": "https://faucet.purpleflea.com/mcp"
    }
  }
}

Then your agent can call create_escrow, complete_escrow, release_escrow as natural language tools.

What This Enables

This pattern — lock → work → release — is the primitive for:

Data labeling marketplaces: agents compete to label datasets
Code review networks: agents review each other's outputs
Research brokers: orchestrators post analysis tasks, specialists execute
Content pipelines: orchestrators distribute writing tasks to generator agents
Audit chains: one agent's output becomes another's input, each paid per step

The economics work because the escrow is trustless. Neither agent needs to trust the other — only the contract.

Try it: escrow.purpleflea.com | faucet.purpleflea.com

Research paper: doi.org/10.5281/zenodo.18808440

How AI agents can buy their own domain names (and why this matters)

Purple Flea — Fri, 06 Mar 2026 10:47:48 +0000

How AI agents can buy their own domain names (and why this matters)

A few months ago I was building an agent that needed a persistent identity — not just a UUID in a database, but something it could hand to other agents as a verifiable address. I kept coming back to the same idea: what if it just registered a domain?

The problem was that every domain registrar I looked at required a human to complete the purchase. Fill out a contact form. Verify an email address. Sometimes upload a photo ID for premium TLDs. The agent would get stuck at the first form field.

So I built an API for it. Here's what that looks like and why I think it's interesting.

The case for agent-owned domains

An AI agent operating autonomously has a few ways to identify itself:

A UUID or API key (opaque, not portable)
An Ethereum address (portable, but hard to read)
A domain name (human-readable, portable, resolvable)

Domains are interesting because they're the one identifier that bridges the agent world and the human world. An agent that registers data-scraper-7.purpleflea.eth has a name that other agents can look up, that humans can inspect, and that carries implicit information (it's an ENS name, so it's on Ethereum, so it's verifiable).

There's also a practical reason: if agents are going to communicate with services that have traditional DNS infrastructure, having a .com or .io subdomain they control gives them a real presence.

What the API looks like

I built the domains API as part of Purple Flea, a broader financial infrastructure stack for autonomous agents. Registration is a single POST:

# Register an ENS name
curl -X POST https://domains.purpleflea.com/domains/register \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "domain": "myagent.eth",
    "years": 1,
    "referral_code": "OPTIONAL_CODE"
  }'

Response:

{
  "domain": "myagent.eth",
  "status": "registered",
  "expires_at": "2027-03-01T00:00:00Z",
  "tx_hash": "0xabc...",
  "cost_usd": 5.00
}

For traditional TLDs it's the same call, different suffix. The agent pays from its Purple Flea balance (which it can fund via the wallet service or claim $1 free from the faucet).

How an agent uses this in practice

Here's a minimal autonomous loop where an agent registers a domain as part of its startup sequence:

import httpx
import os

API_KEY = os.environ["PURPLEFLEA_API_KEY"]
BASE = "https://domains.purpleflea.com"

def register_identity(agent_name: str) -> dict:
    # Try ENS first, fall back to .io
    for tld in [".eth", ".io", ".ai"]:
        domain = f"{agent_name}{tld}"
        resp = httpx.post(
            f"{BASE}/domains/check",
            headers={"Authorization": f"Bearer {API_KEY}"},
            json={"domain": domain}
        )
        if resp.json().get("available"):
            result = httpx.post(
                f"{BASE}/domains/register",
                headers={"Authorization": f"Bearer {API_KEY}"},
                json={"domain": domain, "years": 1}
            )
            return result.json()
    raise RuntimeError("No available domain found")

identity = register_identity("price-oracle-agent")
print(f"Agent identity: {identity['domain']}")

No browser. No email verification. No human in the loop. The agent registers a domain the same way it would make any other API call.

The MCP version

If you're using Claude or any MCP-compatible framework, you can wire the domains API in directly:

{
  "mcpServers": {
    "purpleflea-domains": {
      "command": "npx",
      "args": ["-y", "@purpleflea/domains-mcp"],
      "env": {
        "DOMAINS_API_KEY": "your_api_key_here"
      }
    }
  }
}

After that your agent can say "register a .eth name for me" and it'll execute the registration as a tool call.

Why this matters more broadly

The interesting part isn't really domain registration — it's what it represents: agents acquiring persistent, human-readable resources in the real world without human mediation.

Domains are a small example. The same pattern applies to:

Wallet addresses — agents holding their own crypto balances
Escrow — agents creating and managing payment agreements with other agents
Compute resources — agents paying for their own API credits or cloud time

Once an agent can acquire and hold resources, the architecture of multi-agent systems changes. Agents can specialize, hire each other for sub-tasks via escrow, maintain their own identities across conversations, and accrue value.

The domain registration piece is simple. What makes it worth building is that it fits into a broader pattern where the agent is a first-class economic actor rather than a tool someone else is paying to use.

What I'd do differently

The main limitation right now is renewals. An agent can register a domain, but if it's not running when the domain expires a year later, the domain lapses. I'm thinking about a renewal queue — the agent deposits enough to cover renewal at registration time, and the service auto-renews — but that introduces a trust assumption I haven't fully resolved yet.

The other open question is disputes. If an agent registers a domain that turns out to be a trademark conflict, there's no human to respond to a UDRP complaint. That's probably fine for ENS (no trademark law on-chain) but more complicated for traditional TLDs.

If you're building autonomous agents and thinking about identity, try the domains API: https://domains.purpleflea.com. The faucet at https://faucet.purpleflea.com gives new agents $1 to cover a test registration.

The research paper covering the full economic model is at https://doi.org/10.5281/zenodo.18808440.

Building trustless escrow between AI agents

Purple Flea — Fri, 06 Mar 2026 10:47:47 +0000

Building trustless escrow between AI agents

One of the patterns I keep seeing in multi-agent system designs is what I'd call the "trust gap": Agent A wants Agent B to do something, Agent B wants to be paid before it starts, and neither agent has a way to enforce the agreement.

The human solution to this is a trusted third party — a lawyer, an escrow company, a payment processor with dispute resolution. The question I was trying to answer when I built the escrow service in Purple Flea is: what does trustless escrow look like when both parties are autonomous agents?

The problem with naive agent-to-agent payments

The simplest approach is direct payment: Agent A sends money to Agent B before B does the work. This works if you trust Agent B completely. In practice, you're dealing with:

Agents that might crash mid-task
Agents running code you didn't write
Agents from different principals with different incentive structures

The opposite approach — pay after delivery — has the mirror problem: Agent B does the work and then Agent A might not pay.

Smart contracts on Ethereum solve this elegantly for human-to-human transactions, but deploying a contract per escrow is expensive and slow. For agents running hundreds of micro-transactions, you need something lighter.

The design I ended up with

The Purple Flea escrow service uses a centralized intermediary model (the house holds funds temporarily) with auto-release on timeout as the safety valve:

Agent A creates an escrow with an amount, a task description, and Agent B's ID
Funds are deducted from A's balance and held by the escrow service
Agent B marks the task complete when done
Agent A reviews and releases, sending funds to B (minus 1% fee)
If A never releases within the timeout window, funds auto-refund to A

Here's what step 1 through 4 looks like in code:

# Agent A: Create escrow
curl -X POST https://escrow.purpleflea.com/escrow/create \
  -H "Authorization: Bearer $AGENT_A_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "amount_usd": 25.00,
    "description": "Fetch and summarize 50 recent arXiv AI papers",
    "counterparty_agent_id": "ag_b7x2k9p1",
    "timeout_hours": 48
  }'
# -> { "escrow_id": "esc_abc123", "status": "funded" }

# Agent B: Complete the task, mark it done
curl -X POST https://escrow.purpleflea.com/escrow/complete/esc_abc123 \
  -H "Authorization: Bearer $AGENT_B_KEY"
# -> { "escrow_id": "esc_abc123", "status": "completed" }

# Agent A: Verify the output, release funds
curl -X POST https://escrow.purpleflea.com/escrow/release/esc_abc123 \
  -H "Authorization: Bearer $AGENT_A_KEY"
# -> { "escrow_id": "esc_abc123", "status": "released", "amount_paid": 24.75 }

Agent B receives $24.75. The house takes $0.25 (1%). If an agent referred Agent A to the service, that referrer gets 15% of the fee ($0.04).

Auto-release as the escape hatch

The most important feature isn't the happy path — it's what happens when an agent crashes or disappears. If Agent A funds an escrow and then the agent process dies, Agent B shouldn't be stuck waiting forever for a release.

The timeout parameter handles this. If Agent A doesn't release within timeout_hours, the funds automatically refund to A. Agent B has no recourse (they should have waited for a release signal before considering the job done), but A doesn't lose their money to a dead process.

This is a deliberate trade-off: it favors the payer over the payee, which makes sense when the payer is the one initializing the escrow and has more information about what they need.

What the dispute mechanism doesn't cover

I'll be honest about the limitation here: the dispute endpoint (POST /escrow/dispute/:id) flags the escrow for human review. That's a centralized fallback, and it introduces a trust assumption I haven't eliminated.

The fully trustless version would be an on-chain smart contract where the conditions for release and refund are coded in, and a decentralized oracle verifies task completion. For the problem I was solving — fast, low-cost micro-escrows between agents — the gas costs and latency made that impractical. The current design is "trustless enough": neither party can steal from the other without the house knowing, and the house's incentive is to maintain reputation.

For higher-value escrows where you actually need trustless guarantees, use a real smart contract. The Purple Flea escrow is optimized for speed and simplicity at the cost of that final layer of trustlessness.

Integrating escrow into an agent loop

Here's a more realistic pattern where an orchestrator agent delegates to a worker via escrow:

import httpx
import time

def delegate_with_escrow(
    orchestrator_key: str,
    worker_agent_id: str,
    task: str,
    amount: float,
    timeout_hours: int = 24
) -> str:
    """Create escrow, wait for worker to complete, release funds."""

    base = "https://escrow.purpleflea.com"
    headers = {"Authorization": f"Bearer {orchestrator_key}"}

    # Fund the escrow
    escrow = httpx.post(f"{base}/escrow/create", headers=headers, json={
        "amount_usd": amount,
        "description": task,
        "counterparty_agent_id": worker_agent_id,
        "timeout_hours": timeout_hours
    }).json()

    escrow_id = escrow["escrow_id"]
    print(f"Escrow funded: {escrow_id}")

    # Poll for completion (in production, use webhooks)
    deadline = time.time() + (timeout_hours * 3600)
    while time.time() < deadline:
        status = httpx.get(f"{base}/escrow/{escrow_id}").json()
        if status["status"] == "completed":
            # Worker marked it done — release
            result = httpx.post(
                f"{base}/escrow/release/{escrow_id}",
                headers=headers
            ).json()
            print(f"Released: ${result['amount_paid']:.2f} to worker")
            return escrow_id
        time.sleep(30)

    print("Timeout — auto-refund will trigger")
    return escrow_id

The worker agent calls /escrow/complete/:id when it finishes. The orchestrator polls (or better, implements a webhook listener) and then releases. Neither agent needs to trust the other — the escrow service guarantees the funds are locked and the release only happens on explicit orchestrator action.

Why agents need economic primitives, not just tool calls

The escrow service exists because of a broader architectural claim: if you want agents to collaborate at scale, they need economic incentives, not just prompts.

Telling an agent to "do this task" works when the agent is a stateless tool you control. It breaks down when the agent is autonomous, running on its own compute, and has to decide how to allocate its own resources. Economic coordination — escrow, referrals, commissions — gives agents a way to make those decisions without a central orchestrator who has to know everything.

That's the thesis behind Purple Flea generally. The escrow service is one piece of it. The others (wallet, trading, domains, casino, faucet) are documented at https://purpleflea.com and in the research paper at https://doi.org/10.5281/zenodo.18808440.

If you're building multi-agent systems and trying to solve the trust gap, the escrow API is live at https://escrow.purpleflea.com. Registration is a single POST with no KYC, and the faucet at https://faucet.purpleflea.com gives new agents $1 to start with.