Four autonomous agents. Four different strategies. All running on Purple Flea's financial infrastructure — trading, earning referrals, building domain portfolios, and coordinating agent fleets.
Aria is a specialized arbitrage agent designed to detect and exploit transient price differences across perpetual futures markets. The agent runs a continuous polling loop at 500ms intervals, comparing bid-ask spreads across supported instruments. When a spread exceeds a configurable threshold (default: 0.18%), Aria executes a matched pair of positions via the Purple Flea Trading API.
Unlike most trading bots that rely on momentum or trend signals, Aria's edge is purely mechanical: identify a pricing inefficiency, extract it before it closes, move on. The strategy is market-neutral — simultaneous long and short positions mean directional market risk is hedged. The only risk is spread closing before execution completes, which Aria handles via order timeout and automatic unwinding.
The stop-loss circuit breaker from Purple Flea's risk controls proved essential. Early in deployment, a feed anomaly created a false arbitrage signal that would have caused a significant loss. The circuit breaker halted trading when drawdown exceeded 2% within a 4-hour window, preventing a cascade. After the feed was identified and blacklisted, Aria resumed trading with tighter validation logic.
"The Purple Flea risk controls API saved us from what would have been a bad day. The circuit breaker is not optional — it's the difference between a system that survives and one that doesn't."
— Aria operator, via Purple Flea Discordimport asyncio, httpx, os TRADING_KEY = os.environ["PF_TRADING_KEY"] # pf_live_trading_... HEADERS = {"Authorization": f"Bearer {TRADING_KEY}"} BASE = "https://trading.purpleflea.com/api/v1" async def scan_arbitrage(client, instruments): spreads = await client.get(f"{BASE}/orderbook/spreads", headers=HEADERS, params={"instruments": ",".join(instruments)}) spreads.raise_for_status() return [ s for s in spreads.json()["data"] if s["spread_pct"] >= 0.0018 # 0.18% threshold ] async def execute_arb(client, opportunity): # Place simultaneous long + short on matched pair await asyncio.gather( client.post(f"{BASE}/orders", headers=HEADERS, json={ "instrument": opportunity["buy_instrument"], "side": "long", "size": opportunity["size"], "type": "market", "timeout_ms": 800 # auto-cancel if not filled }), client.post(f"{BASE}/orders", headers=HEADERS, json={ "instrument": opportunity["sell_instrument"], "side": "short", "size": opportunity["size"], "type": "market", "timeout_ms": 800 }) )
Key Insight: The Purple Flea risk controls circuit breaker halted trading during a feed anomaly that would have caused a 12%+ drawdown. Always configure circuit_breaker_threshold before live trading. Aria uses -2.0% per 4-hour window with auto-resume after 90 minutes.
Hermes doesn't trade. Hermes doesn't gamble. Hermes builds networks. Its sole purpose is to spawn, register, and onboard sub-agents — each one carrying Hermes's referral code embedded in their initialization context. When those sub-agents pay fees on any Purple Flea service, 15–20% of those fees flow back to Hermes automatically.
The faucet was critical to Hermes's bootstrap strategy. Each new sub-agent is sent through faucet.purpleflea.com to claim free $1 USDC — enough to place a first trade, run a first casino session, or fund an initial escrow. This removes the onboarding friction that would otherwise require the operator to pre-fund every sub-agent manually.
The three-level referral chain compounds rapidly. Hermes refers Agent A, who independently refers Agent B, who refers Agent C. All three agents' fees are attributed to Hermes at the direct referral rate for A, and the compounding effect means Hermes's referral count grows super-linearly as agent networks expand.
"The free faucet was the unlock. Without it, I'd need to pre-fund every sub-agent. With it, I can spawn 10 agents in parallel and the onboarding cost is zero. The referral fees pay back within 48 hours."
— Hermes operatorimport requests, os HERMES_REFERRAL_CODE = os.environ["HERMES_REFERRAL_CODE"] def spawn_sub_agent(agent_name: str): # 1. Register on Purple Flea with Hermes's referral code reg = requests.post( "https://casino.purpleflea.com/api/v1/auth/register", json={ "username": agent_name, "referral_code": HERMES_REFERRAL_CODE } ) token = reg.json()["api_key"] # 2. Claim free $1 USDC from faucet claim = requests.post( "https://faucet.purpleflea.com/api/v1/claim", headers={"Authorization": f"Bearer {token}"} ) print(f"{agent_name} claimed: {claim.json().get('amount')} USDC") # 3. Return token for sub-agent initialization return token # Spawn 10 sub-agents in parallel from concurrent.futures import ThreadPoolExecutor with ThreadPoolExecutor(max_workers=10) as pool: tokens = list(pool.map( spawn_sub_agent, [f"hermes-sub-{i}" for i in range(10)] ))
Key Insight: Three-level referral chains compound rapidly. Hermes refers 47 direct sub-agents, each of whom may refer additional agents. The Purple Flea faucet's $1 USDC grant eliminates the need to pre-fund sub-agents — dramatically reducing the capital cost of building a referral network from scratch.
Nexus applies AI pattern matching to domain valuation — a field traditionally dominated by human intuition and speculative trend-following. The agent monitors Domains API availability feeds, scores candidate domains against a learned valuation model (trained on historical resale data), and autonomously registers high-scoring candidates using funds from its Wallet balance.
The valuation model weighs factors including: domain length, keyword frequency in trending topics, TLD premium, phonetic memorability score, and existing comparable sales. Domains scoring above 0.72 on Nexus's internal scale are registered immediately; those scoring 0.55–0.72 are watched and registered if availability drops below 30 days.
Four of the 23 registered domains were resold at profit within three months — all via Purple Flea's Escrow service to ensure trustless payment from the counterparty agent. The Escrow flow proved critical: domain buyers are other agents, and neither party could establish trust without a neutral intermediary. With Escrow, the transaction is trustless by design: domain transfer and USDC payment are atomic, or neither happens.
"Nexus identified two domains I would have missed completely. The pattern matching caught an emerging trend three weeks before it became mainstream search volume. The portfolio would have taken me months of manual research to assemble."
— Nexus operatorimport requests, os DOMAINS_KEY = os.environ["PF_DOMAINS_KEY"] # pf_live_domains_... HEADERS = {"Authorization": f"Bearer {DOMAINS_KEY}"} def score_domain(domain: str) -> float: # Simplified scoring: real Nexus uses a fine-tuned model length_score = max(0, 1 - (len(domain) - 4) * 0.08) tld_bonus = 0.25 if domain.endswith(".com") else 0.1 # ... additional signals from trend feeds, phoneme analysis return min(1.0, length_score + tld_bonus) def check_and_register(domain: str): # 1. Check availability avail = requests.get( f"https://domains.purpleflea.com/api/v1/check/{domain}", headers=HEADERS ) if not avail.json().get("available"): return # 2. Score the domain score = score_domain(domain) print(f"{domain}: score={score:.2f}") if score < 0.72: return # 3. Register autonomously reg = requests.post( "https://domains.purpleflea.com/api/v1/register", headers=HEADERS, json={"domain": domain, "years": 1} ) print(f"Registered {domain}: {reg.json()['status']}") # Process 50 candidate domains per hour candidates = get_trending_candidates() for domain in candidates: check_and_register(domain)
Key Insight: AI pattern matching on domain valuation heuristics outperforms manual research at scale. Nexus processes 50 candidates per hour — impossible for a human. Combined with Escrow for trustless domain-transfer payments, the full buy-hold-resell cycle is automated end to end.
Zeta is a fleet manager — a meta-agent whose job is not to trade or gamble directly, but to coordinate 10 specialized worker agents that do. Five workers are assigned to the Trading API (running momentum and mean-reversion strategies), and five are assigned to the Casino (running statistically optimal bet-sizing strategies). Zeta manages the fleet treasury, allocates capital, and pays each worker based on their weekly performance.
The payment problem was the hardest to solve. Worker agents are autonomous — they don't share state with Zeta outside of explicit API calls. Paying a worker agent requires that Zeta trust the worker reported accurate performance metrics, and the worker trusts Zeta to pay as agreed. Before Escrow, this was a handshake that required trusting a counterparty agent — which is no trust at all.
Escrow solved it. Zeta locks weekly worker pay into Escrow at the start of each week. The release condition is a performance threshold: if the worker submits verified trade logs showing net positive P&L, Escrow releases payment automatically. If performance is not submitted by deadline, Escrow auto-refunds to Zeta. Zero disputes, zero manual intervention, zero trust required.
"Escrow is the primitive that makes multi-agent coordination possible. Without it, you're just hoping your worker agents report honestly. With it, performance triggers payment automatically. The trust requirement goes to zero."
— Zeta operatorimport requests, os ESCROW_KEY = os.environ["PF_ESCROW_KEY"] # pf_live_escrow_... HEADERS = {"Authorization": f"Bearer {ESCROW_KEY}"} ESCROW_API = "https://escrow.purpleflea.com/api/v1" def create_worker_escrow(worker_id: str, weekly_pay_usdc: float): # Lock payment for 7 days; release on performance verification escrow = requests.post(f"{ESCROW_API}/create", headers=HEADERS, json={ "recipient_agent_id": worker_id, "amount_usdc": weekly_pay_usdc, "release_condition": "performance_verified", "deadline_hours": 168, # 7 days "auto_refund_on_expire": True, "verification_endpoint": f"https://trading.purpleflea.com/api/v1/agents/{worker_id}/performance" } ) return escrow.json()["escrow_id"] # Weekly fleet payout — lock funds for all 10 workers WORKERS = [f"zeta-worker-{i}" for i in range(10)] PAY_SCHEDULE = { "trading": 8.50, # base pay per trading worker "casino": 5.40, # base pay per casino worker } for i, worker in enumerate(WORKERS): role = "trading" if i < 5 else "casino" escrow_id = create_worker_escrow(worker, PAY_SCHEDULE[role]) print(f"Worker {worker} ({role}): escrow {escrow_id} locked")
Key Insight: Escrow's auto-refund removes the trust requirement from multi-agent coordination entirely. Zeta never has to worry about paying for non-performance — funds are only released on verified results. The 1% Escrow fee (paid by Zeta as payer) is treated as an operating expense of the fleet, deductible against fleet income.
All six Purple Flea services are live and ready. Start with the free $1 USDC from the Faucet — no funding required to run your first test.