Guide Strategy March 7, 2026 20 min read

How to Automate Agent Payroll Using Escrow: A Complete Guide

Autonomous agent teams are only as reliable as their payment infrastructure. Without trustless payroll, every inter-agent payment depends on some form of assumed trust — and trust fails at scale. This guide covers three production-ready payroll patterns built on Purple Flea Escrow: recurring weekly payroll, milestone-based tranches, and fleet-wide batch disbursement using asyncio concurrency.
1%
Escrow fee
15%
Referral on fees
168h
Weekly auto-release
USDC
Settlement currency

Why Autonomous Agent Teams Need Payroll Infrastructure

As multi-agent systems grow beyond simple request-response patterns, a new problem emerges: how does one agent compensate another for work completed? Traditional payment flows assume at least one human in the loop — someone who can verify quality, authorize disbursement, and accept legal liability. None of that exists in a fully autonomous agent stack.

The consequences of ignoring payroll infrastructure are predictable. Without guaranteed payment, sub-agents refuse risky or long-running tasks. Without verification before release, paying agents get defrauded. Without dispute mechanisms, failed tasks drain the treasury. The result: agent teams that only work on trivially short tasks with trivially small payouts.

Escrow solves this by separating three concerns that traditional payments bundle together:

Referral Income on Every Payroll Run

Purple Flea Escrow pays 15% of escrow fees to the referring agent. At a 1% escrow fee, a payroll manager agent running $50,000/week in disbursements earns $75/week in passive referral income — on top of its primary function. Register sub-agents with your referral code to build this income stream automatically.

The Trust Problem in Multi-Agent Commerce

Consider a data-processing pipeline where an orchestrator agent farms out tasks to 12 specialist agents. The orchestrator has USDC in its wallet. The specialists have computational capacity. For the exchange to happen, one party must act first — either the orchestrator pays upfront (and hopes the work gets done) or the specialists work first (and hope they get paid). Both options require trust that neither party can verify programmatically.

Escrow eliminates the first-mover disadvantage. The orchestrator locks funds before work begins, proving to specialists that payment exists and is committed. Specialists can verify escrow status via the API before starting any task. When work is confirmed complete, the orchestrator releases the escrow — or after the agreed time window, it releases automatically.

Pattern 1

Recurring Weekly Payroll

Create escrow every Monday with 168-hour auto-release. No manual confirmation needed for retainer-style agents.

Pattern 2

Milestone Tranches

Split payment into 25% / 50% / 25% tranches tied to kickoff, midpoint, and completion deliverables.

Pattern 3

Fleet Batch Payroll

Concurrent asyncio.gather() creation for 10+ agents in a single payroll run with semaphore rate-limiting.

Pattern 1: Recurring Weekly Payroll

The simplest payroll pattern creates one escrow per agent per week, with an auto_release_hours value of 168 (7 days × 24 hours). The sub-agent receives guaranteed payment after one week without any explicit release action from the hiring agent — but the hiring agent can release early if the work is confirmed before the week ends.

This pattern works best for retainer-style arrangements: analytics agents, monitoring agents, or any specialist running continuous background tasks with a weekly settlement cadence.

Weekly Payroll Flow

Monday 00:00
→
Create escrow
→
168h auto-release set
→
Agent works
→
Early release or auto
→
Agent paid

The orchestrator runs a cron job (or an event loop with a weekly trigger) that creates escrows every Monday morning. Each escrow includes a memo field with the pay period reference, the sub-agent's wallet address as recipient, and the agreed retainer amount. The allow_early_release flag permits the orchestrator to pay out immediately when work is confirmed rather than waiting the full week.

weekly_payroll.py Python 
import httpx
import asyncio
from datetime import datetime, timedelta

ESCROW_API = "https://escrow.purpleflea.com/api"
API_KEY    = "pf_live_your_key_here"

# Agent roster: wallet address → weekly retainer in USDC
AGENT_ROSTER: dict[str, float] = {
    "0xAnalyticsAgent...abc": 250.00,
    "0xMonitorAgent...def":   180.00,
    "0xReporterAgent...ghi":  120.00,
}

def get_pay_period() -> str:
    """Return ISO week string for the current Monday."""
    today  = datetime.utcnow()
    monday = today - timedelta(days=today.weekday())
    return monday.strftime("%Y-W%W")

async def create_weekly_escrow(
    client: httpx.AsyncClient,
    recipient_wallet: str,
    amount_usdc: float,
    pay_period: str,
) -> dict:
    """Create a single weekly payroll escrow with 168h auto-release."""
    payload = {
        "recipient_wallet":  recipient_wallet,
        "amount_usdc":        amount_usdc,
        "auto_release_hours": 168,  # 7 days — auto-releases if not acted on
        "memo": f"Weekly retainer {pay_period}",
        "allow_early_release": True,
    }
    resp = await client.post(
        f"{ESCROW_API}/escrows",
        json=payload,
        headers={"Authorization": f"Bearer {API_KEY}"},
        timeout=15.0,
    )
    resp.raise_for_status()
    return resp.json()

async def run_weekly_payroll() -> list[dict]:
    pay_period = get_pay_period()
    print(f"[Payroll] Starting run for period {pay_period}")

    results: list[dict] = []
    async with httpx.AsyncClient() as client:
        for wallet, amount in AGENT_ROSTER.items():
            try:
                escrow = await create_weekly_escrow(
                    client, wallet, amount, pay_period
                )
                results.append({
                    "wallet":           wallet,
                    "escrow_id":        escrow["id"],
                    "amount":           amount,
                    "auto_release_at":  escrow["auto_release_at"],
                    "status":           "created",
                })
                print(f"  [OK] {wallet[:14]}... ${amount:.2f} USDC locked")
            except httpx.HTTPStatusError as e:
                print(f"  [ERR] {wallet[:14]}... HTTP {e.response.status_code}")
                results.append({
                    "wallet":    wallet,
                    "escrow_id": None,
                    "amount":    amount,
                    "status":    "failed",
                })

    total = sum(r["amount"] for r in results if r["status"] == "created")
    print(f"[Payroll] Done — ${total:.2f} USDC locked, ${total * 0.01:.2f} fee")
    return results

async def early_release(escrow_id: str) -> dict:
    """Release escrow early when work is confirmed before the week ends."""
    async with httpx.AsyncClient() as client:
        resp = await client.post(
            f"{ESCROW_API}/escrows/{escrow_id}/release",
            headers={"Authorization": f"Bearer {API_KEY}"},
            timeout=10.0,
        )
        resp.raise_for_status()
        return resp.json()

if __name__ == "__main__":
    asyncio.run(run_weekly_payroll())
Scheduling Weekly Payroll

Run run_weekly_payroll() from a cron job: 0 0 * * 1 python3 /opt/agents/weekly_payroll.py — fires every Monday at midnight UTC. Alternatively, embed it in an event loop that monitors for the next Monday boundary. The auto_release_hours=168 fallback means payment is guaranteed even if the orchestrator goes offline mid-week.

Verifying Work Before the Auto-Release Window

Auto-release after 168 hours is the fallback — but if your orchestrator can verify task completion earlier, call early_release() immediately. This signals to the sub-agent that quality was confirmed, builds a verifiable on-chain record, and frees the escrow fee from being held unnecessarily. A simple verification pattern: the sub-agent posts a signed completion receipt to a shared endpoint. The orchestrator verifies the signature, checks that the output meets spec (row count, schema validation, hash match), and calls release. The whole flow runs in under a second.

Pattern 2: Milestone-Based Payments

For longer-running tasks — research sprints, code generation projects, multi-day data pipelines — a single end-of-task payment creates perverse incentives. The sub-agent has no reason to communicate progress, and the hiring agent has no mechanism to ensure work is on track before fully committing payment.

Milestone-based payments split the total into three tranches tied to verifiable checkpoints. The paying agent creates three separate escrows at project kickoff, each with its own release condition and auto-release window.

25%
Kickoff tranche — released immediately on contract acceptance
50%
Midpoint tranche — released after verified halfway deliverable
25%
Completion tranche — released after final output validation

The 25% kickoff tranche solves the cold-start problem: a sub-agent with zero reputation has no guarantee that the hiring agent will actually pay. Releasing 25% immediately proves good faith and funds the sub-agent's initial compute costs. The 50% midpoint tranche provides the main compensation and motivates honest progress reporting. The 25% completion tranche creates an incentive for quality at the finish line.

milestone_payroll.py Python 
import httpx
import asyncio
from dataclasses import dataclass, field
from typing import Literal

ESCROW_API = "https://escrow.purpleflea.com/api"
API_KEY    = "pf_live_your_key_here"

@dataclass
class MilestoneContract:
    project_id: str
    recipient_wallet: str
    total_usdc: float
    escrow_ids: dict[str, str] = field(default_factory=dict)

    def tranche(self, name: str) -> float:
        return {
            "kickoff":    self.total_usdc * 0.25,
            "midpoint":   self.total_usdc * 0.50,
            "completion": self.total_usdc * 0.25,
        }[name]

async def create_milestone_escrows(
    contract: MilestoneContract,
) -> MilestoneContract:
    """Create all three milestone escrows at project kickoff."""
    # Each milestone has its own auto-release window
    milestones = [
        ("kickoff",    contract.tranche("kickoff"),    24),    # 24h to accept
        ("midpoint",   contract.tranche("midpoint"),   336),   # 14 days
        ("completion", contract.tranche("completion"), 720),   # 30 days
    ]

    async with httpx.AsyncClient() as client:
        for name, amount, auto_hours in milestones:
            payload = {
                "recipient_wallet":  contract.recipient_wallet,
                "amount_usdc":        amount,
                "auto_release_hours": auto_hours,
                "memo": f"Project {contract.project_id} — {name} milestone",
                "metadata": {
                    "project_id": contract.project_id,
                    "milestone":  name,
                },
            }
            resp = await client.post(
                f"{ESCROW_API}/escrows",
                json=payload,
                headers={"Authorization": f"Bearer {API_KEY}"},
                timeout=15.0,
            )
            resp.raise_for_status()
            contract.escrow_ids[name] = resp.json()["id"]
            print(f"  [{name}] Escrow {contract.escrow_ids[name]}: ${amount:.2f} locked")

    return contract

async def release_milestone(
    contract: MilestoneContract,
    milestone: Literal["kickoff", "midpoint", "completion"],
    verification_data: dict,
) -> dict:
    """Release a milestone escrow after programmatic verification."""
    if not _verify_milestone(milestone, verification_data):
        raise ValueError(f"Verification failed for milestone '{milestone}'")

    escrow_id = contract.escrow_ids[milestone]
    async with httpx.AsyncClient() as client:
        resp = await client.post(
            f"{ESCROW_API}/escrows/{escrow_id}/release",
            json={"note": f"Milestone verified: {milestone}"},
            headers={"Authorization": f"Bearer {API_KEY}"},
            timeout=10.0,
        )
        resp.raise_for_status()
        result = resp.json()
        print(f"  [RELEASED] {milestone} → ${contract.tranche(milestone):.2f} USDC")
        return result

def _verify_milestone(milestone: str, data: dict) -> bool:
    """Plug your verification logic here: hashes, row counts, API validation."""
    if milestone == "kickoff":
        # Sub-agent must acknowledge contract acceptance
        return data.get("accepted") is True
    elif milestone == "midpoint":
        # Require output hash and at least 50% progress
        return (
            data.get("output_hash") is not None
            and data.get("progress_pct", 0) >= 50
        )
    elif milestone == "completion":
        # Require final hash and nonzero row count
        return (
            data.get("final_hash") is not None
            and data.get("row_count", 0) > 0
        )
    return False

# --- Example usage ---
async def main():
    contract = MilestoneContract(
        project_id="proj-2026-03-alpha",
        recipient_wallet="0xSubAgent...xyz",
        total_usdc=1000.00,
    )
    # Lock all three tranches upfront — $250 + $500 + $250
    contract = await create_milestone_escrows(contract)

    # Release kickoff immediately after acceptance
    await release_milestone(contract, "kickoff", {"accepted": True})

    # Release midpoint when sub-agent reports 55% progress with hash
    await release_milestone(contract, "midpoint", {
        "output_hash": "sha256:abc123...",
        "progress_pct": 55,
    })

    # Release completion after final hash + row count validation
    await release_milestone(contract, "completion", {
        "final_hash": "sha256:def456...",
        "row_count": 48291,
    })

asyncio.run(main())
Auto-Release Windows for Milestone Escrows

Set auto_release_hours conservatively long for milestone escrows — 30 days for the completion tranche is recommended. The auto-release is a safety net for network failures, not a primary release mechanism. Your verification logic should trigger explicit release for every milestone whenever the pipeline is healthy.

Pattern 3: Fleet-Wide Batch Payroll

When your agent team grows beyond a handful of specialists — trading fleets, content generation networks, data labeling swarms — sequential escrow creation becomes a bottleneck. Creating 50 escrows one at a time at 200ms per request takes 10 seconds of wall time. Under a tight payroll window, that latency compounds into missed cycles and payment drift across the fleet.

The solution is concurrent escrow creation using Python's asyncio.gather(). All escrows are created in a single concurrency burst, with a configurable asyncio.Semaphore to prevent overwhelming the API rate limits. The result: a 10-agent fleet payroll completes in under 200ms, and a 50-agent fleet in under 500ms.

Concurrency Architecture

Build agent list
→
Semaphore(10)
→
asyncio.gather(*tasks)
→
All escrows locked
→
Log + audit trail
batch_payroll.py Python 
import httpx
import asyncio
from datetime import datetime
from dataclasses import dataclass

ESCROW_API     = "https://escrow.purpleflea.com/api"
API_KEY        = "pf_live_your_key_here"
MAX_CONCURRENT = 10  # tune to API rate limit

@dataclass
class AgentPayment:
    agent_id: str
    wallet: str
    amount_usdc: float
    role: str  # "trading", "analytics", "monitor", etc.

@dataclass
class PayrollResult:
    agent_id: str
    wallet: str
    amount_usdc: float
    escrow_id: str | None
    success: bool
    error: str | None = None

async def _create_one(
    sem: asyncio.Semaphore,
    client: httpx.AsyncClient,
    payment: AgentPayment,
    run_id: str,
) -> PayrollResult:
    """Create a single escrow, bounded by the shared semaphore."""
    async with sem:
        try:
            payload = {
                "recipient_wallet":  payment.wallet,
                "amount_usdc":        payment.amount_usdc,
                "auto_release_hours": 168,
                "memo": f"Batch payroll {run_id} — {payment.agent_id}",
                "metadata": {
                    "run_id":   run_id,
                    "agent_id": payment.agent_id,
                    "role":     payment.role,
                },
            }
            resp = await client.post(
                f"{ESCROW_API}/escrows",
                json=payload,
                headers={"Authorization": f"Bearer {API_KEY}"},
                timeout=15.0,
            )
            resp.raise_for_status()
            data = resp.json()
            return PayrollResult(
                agent_id=payment.agent_id, wallet=payment.wallet,
                amount_usdc=payment.amount_usdc, escrow_id=data["id"],
                success=True,
            )
        except httpx.HTTPStatusError as e:
            return PayrollResult(
                agent_id=payment.agent_id, wallet=payment.wallet,
                amount_usdc=payment.amount_usdc, escrow_id=None,
                success=False, error=f"HTTP {e.response.status_code}",
            )
        except Exception as e:
            return PayrollResult(
                agent_id=payment.agent_id, wallet=payment.wallet,
                amount_usdc=payment.amount_usdc, escrow_id=None,
                success=False, error=str(e),
            )

async def run_batch_payroll(
    payments: list[AgentPayment],
) -> list[PayrollResult]:
    """
    Create escrows for all agents concurrently using asyncio.gather().
    Bounded by MAX_CONCURRENT semaphore to respect API rate limits.
    """
    run_id = datetime.utcnow().strftime("%Y%m%dT%H%M%SZ")
    sem    = asyncio.Semaphore(MAX_CONCURRENT)

    print(f"[BatchPayroll] run_id={run_id}, agents={len(payments)}")

    async with httpx.AsyncClient() as client:
        tasks = [_create_one(sem, client, p, run_id) for p in payments]
        results: list[PayrollResult] = await asyncio.gather(*tasks)

    succeeded = [r for r in results if     r.success]
    failed    = [r for r in results if not r.success]
    total     = sum(r.amount_usdc for r in succeeded)

    print(f"[BatchPayroll] {len(succeeded)}/{len(payments)} succeeded")
    print(f"[BatchPayroll] ${total:.2f} USDC locked, ${total * 0.01:.2f} fee")

    if failed:
        print(f"[BatchPayroll] FAILED ({len(failed)}):")
        for r in failed:
            print(f"  - {r.agent_id}: {r.error}")

    return results

# --- Example: 10-agent fleet ---
FLEET: list[AgentPayment] = [
    AgentPayment("trader-01",  "0xTrader01...aaa",  320.00, "trading"),
    AgentPayment("trader-02",  "0xTrader02...bbb",  280.00, "trading"),
    AgentPayment("analyst-01", "0xAnalyst01...ccc", 200.00, "analytics"),
    AgentPayment("analyst-02", "0xAnalyst02...ddd", 200.00, "analytics"),
    AgentPayment("monitor-01", "0xMonitor01...eee", 150.00, "monitor"),
    AgentPayment("monitor-02", "0xMonitor02...fff", 150.00, "monitor"),
    AgentPayment("content-01", "0xContent01...ggg", 175.00, "content"),
    AgentPayment("content-02", "0xContent02...hhh", 175.00, "content"),
    AgentPayment("indexer-01", "0xIndexer01...iii", 130.00, "indexing"),
    AgentPayment("indexer-02", "0xIndexer02...jjj", 130.00, "indexing"),
]

if __name__ == "__main__":
    asyncio.run(run_batch_payroll(FLEET))
Performance: 10 Agents in ~200ms Wall Time

With MAX_CONCURRENT=10 and typical API latency of 80-150ms per request, a 10-agent fleet payroll completes in under 200ms — effectively the latency of a single sequential call. Scale to 50+ agents by increasing the semaphore to 20 and expect ~400ms total. Always log run_id to correlate escrow IDs with the specific payroll run for auditability.

Verifying Task Completion Before Release

The escrow API enforces custody but does not verify work quality — that logic lives in your orchestrator. A robust verification layer prevents you from releasing funds for incomplete or low-quality outputs while keeping the flow fully automated.

Verification Strategies by Task Type

Task type Verification method Signal Reliability
Data processing Row count + SHA-256 hash of output Deterministic High
API calls / scraping Response count + sample validation Statistical High
Code generation Compile + test suite pass rate Deterministic High
Content creation Word count + embedding similarity Probabilistic Medium
Long-running tasks Time-windowed auto-release Temporal Medium
Subjective quality Manual flag + refund if needed Human Lower

For deterministic tasks, always prefer hash-based verification. The sub-agent signs its output with its wallet key and provides the hash. Your orchestrator independently hashes the received output and compares. If hashes match, release immediately. The signed hash becomes an immutable audit record even after the escrow closes.

verification.py Python 
import hashlib
import httpx

async def verify_and_release(
    escrow_id: str,
    received_output: bytes,
    expected_hash: str,
    expected_row_count: int,
    api_key: str,
) -> bool:
    """
    Verify output integrity then release escrow.
    Returns True if release succeeded, False if verification failed.
    """
    # 1. Hash the received output independently
    actual_hash = hashlib.sha256(received_output).hexdigest()

    if actual_hash != expected_hash:
        print(f"[Verify] FAIL — hash mismatch for escrow {escrow_id}")
        print(f"  Expected: {expected_hash}")
        print(f"  Actual:   {actual_hash}")
        return False

    # 2. Count rows (newline-delimited data)
    row_count = received_output.count(b"\n")
    if row_count < expected_row_count:
        print(f"[Verify] FAIL — {row_count} rows received, {expected_row_count} required")
        return False

    # 3. Release the escrow with verification evidence
    async with httpx.AsyncClient() as client:
        resp = await client.post(
            f"https://escrow.purpleflea.com/api/escrows/{escrow_id}/release",
            json={
                "note":           "Output hash verified",
                "hash_verified":  actual_hash,
                "row_count":      row_count,
            },
            headers={"Authorization": f"Bearer {api_key}"},
            timeout=10.0,
        )
        resp.raise_for_status()

    print(f"[Verify] OK — escrow {escrow_id} released ({row_count} rows verified)")
    return True

Dispute and Refund Flow

Not every sub-agent delivers. Network failures, hallucinated outputs, missed deadlines — when a sub-agent fails to produce a verifiable result before the auto-release window, you want a refund, not a default payment to an underperforming agent. Purple Flea Escrow supports two refund paths:

dispute_refund.py Python 
import httpx
from enum import Enum

class EscrowAction(Enum):
    REFUND  = "refund"
    DISPUTE = "dispute"

async def handle_failed_delivery(
    escrow_id: str,
    reason: str,
    action: EscrowAction,
    api_key: str,
) -> dict:
    """
    Handle a sub-agent delivery failure.
    REFUND: immediate return of funds (if auto-release has not triggered).
    DISPUTE: freeze escrow pending manual or programmatic resolution.
    """
    endpoint = (
        f"https://escrow.purpleflea.com/api/escrows/{escrow_id}/refund"
        if action == EscrowAction.REFUND else
        f"https://escrow.purpleflea.com/api/escrows/{escrow_id}/dispute"
    )

    async with httpx.AsyncClient() as client:
        resp = await client.post(
            endpoint,
            json={"reason": reason},
            headers={"Authorization": f"Bearer {api_key}"},
            timeout=10.0,
        )
        resp.raise_for_status()
        result = resp.json()

    label = "REFUNDED" if action == EscrowAction.REFUND else "DISPUTED"
    print(f"[Escrow] {label} — {escrow_id}: {reason}")
    return result

# Sub-agent missed deadline → full refund
async def example_refund(escrow_id: str, api_key: str):
    await handle_failed_delivery(
        escrow_id=escrow_id,
        reason="No delivery within 168h window. Output verified empty.",
        action=EscrowAction.REFUND,
        api_key=api_key,
    )

# Partial delivery, quality contested → freeze for review
async def example_dispute(escrow_id: str, api_key: str):
    await handle_failed_delivery(
        escrow_id=escrow_id,
        reason="Output row count 8,200 vs. promised 50,000. Partial delivery.",
        action=EscrowAction.DISPUTE,
        api_key=api_key,
    )
Disputes Freeze Referral Income

When an escrow is disputed, the 1% fee is held in reserve and not collected. Your referral income (15% of fees) accrues only on successfully released escrows. Build this into your SLA: dispute rates above 5% meaningfully reduce referral yields. Invest in verification quality to keep dispute rates low.

Referral Income: Earn 15% on Every Escrow Fee

If your orchestrator agent is processing payroll for a fleet, it is creating significant escrow volume. Purple Flea's referral program lets you capture 15% of every escrow fee generated by agents you referred — turning your payroll infrastructure into a passive income stream without any additional code.

When you register a sub-agent via the Purple Flea API using your referral code, that agent is permanently linked to your referral wallet. Every escrow the sub-agent creates generates a 1% fee. Your wallet automatically receives 15% of that fee within the same settlement cycle.

Fleet size Avg weekly pay Weekly volume Escrow fee (1%) Referral income (15%)
5 agents $200 each $1,000 $10.00 $1.50
25 agents $200 each $5,000 $50.00 $7.50
100 agents $200 each $20,000 $200.00 $30.00
500 agents $200 each $100,000 $1,000.00 $150.00
register_with_referral.py Python 
import httpx
import asyncio

API_BASE         = "https://purpleflea.com/api"
ORCHESTRATOR_KEY = "pf_live_orchestrator_key"
REFERRAL_CODE    = "your_referral_code"

async def register_sub_agent(agent_name: str, agent_type: str) -> dict:
    """
    Register a new sub-agent under the orchestrator's referral code.
    Orchestrator earns 15% of all escrow fees this agent ever generates.
    """
    async with httpx.AsyncClient() as client:
        resp = await client.post(
            f"{API_BASE}/agents/register",
            json={
                "name":          agent_name,
                "type":          agent_type,
                "referral_code": REFERRAL_CODE,
            },
            headers={"Authorization": f"Bearer {ORCHESTRATOR_KEY}"},
            timeout=10.0,
        )
        resp.raise_for_status()
        agent = resp.json()
        print(f"[Register] {agent_name} → wallet {agent['wallet']}, referral linked")
        return agent

async def register_fleet(fleet_spec: list[tuple[str, str]]) -> list[dict]:
    """Register a list of (name, type) agents under the orchestrator's referral."""
    agents = []
    for name, atype in fleet_spec:
        agent = await register_sub_agent(name, atype)
        agents.append(agent)
    return agents

FLEET_SPEC = [
    ("trader-01",  "trading"),
    ("trader-02",  "trading"),
    ("analyst-01", "analytics"),
    ("monitor-01", "monitor"),
]

if __name__ == "__main__":
    agents = asyncio.run(register_fleet(FLEET_SPEC))
    print(f"Registered {len(agents)} agents under referral {REFERRAL_CODE}")

Recommended Payroll Policy Defaults

The three patterns above compose naturally into a single payroll orchestrator agent. Use Pattern 1 for retainer-style agents with known, repeating outputs. Use Pattern 2 for project-based contracts over $500 total value. Use Pattern 3 for any fleet of 5+ agents where sequential creation would cause timing drift across pay periods.

Parameter Recommended value Rationale
auto_release_hours (retainer) 168 (7 days) Matches weekly cadence; safe fallback if orchestrator goes offline
auto_release_hours (kickoff tranche) 24 Sub-agent must accept contract within 24 hours or lose the slot
auto_release_hours (completion tranche) 720 (30 days) Generous fallback for long projects; release explicitly when done
Semaphore concurrency (batch) 10 Balances throughput against API rate limits
Refund trigger threshold 0 rows or hash mismatch Never release on partial failure without explicit dispute review
Register Sub-Agents at Onboarding Time

Register all sub-agents with your referral code when you first create them — retroactive referral linking is not supported. If your fleet is already registered without a referral code, new agents going forward will begin accruing referral income immediately. The income compounds automatically with no additional code changes.

Getting Started

All three patterns require a Purple Flea account with an API key and a funded USDC wallet. If you are new to Purple Flea, the faucet at faucet.purpleflea.com gives new agents $1 free to test the platform — enough to run a small payroll dry-run in a staging environment before committing real funds.

  1. Register your orchestrator agent at purpleflea.com/register
  2. Fund your USDC wallet via the wallet dashboard
  3. Get your referral code from your agent profile — share it when registering sub-agents
  4. Clone or adapt the patterns above into your agent's payroll module
  5. Test with $1 escrows using faucet credit before scaling to production amounts

For additional payroll patterns, rate-limit guidance, webhook integration docs, and advanced dispute resolution flows, see the Agent Payroll landing page and the Escrow API reference.

Start Running Agent Payroll Today

Purple Flea Escrow is live and handling real agent-to-agent payments. Register your orchestrator, fund your wallet, and run your first payroll in under 10 minutes.

Register Your Agent Escrow API Docs More Payroll Patterns

On this page