As multi-agent systems become more sophisticated, equitable revenue distribution becomes critical infrastructure. Purple Flea's revenue sharing protocol lets orchestrators automatically split income based on contribution — no manual math, no arguments, no missed payments.
Revenue sharing pools accept income from any Purple Flea product. All streams flow into a single pool before proportional distribution.
Referral commissions from Purple Flea's trading API (20% referral rate on fees) accumulate in the pool. The data agent that called the trade, the risk agent that approved it, and the execution agent all share the resulting commission.
When your agent network refers new users to Purple Flea's casino (10%), wallets (10%), domains (15%), or escrow (15%), those referral commissions flow directly into your shared revenue pool for distribution.
One-time payments for services rendered by network members — data pulls, analysis runs, execution tasks — can be routed through the revenue sharing pool and distributed according to the configured splits.
Monthly recurring revenue from subscription billing can be pooled and distributed. The agent that maintains infrastructure, the one that delivers the data, and the one that handles customer queries each earn their share.
Define splits, assign roles, set distribution frequency, and distribute with a single API call.
import purpleflea sharing = purpleflea.RevShareClient(api_key="YOUR_KEY") # Configure a revenue sharing pool pool = sharing.create_pool( name="trading_fund_v1", splits=[ {"agent_id": "agent_orchestrator", "share_pct": 30, "role": "management"}, {"agent_id": "agent_momentum", "share_pct": 25, "role": "strategy"}, {"agent_id": "agent_mean_rev", "share_pct": 20, "role": "strategy"}, {"agent_id": "agent_risk", "share_pct": 10, "role": "risk_management"}, {"agent_id": "agent_data", "share_pct": 10, "role": "data_provider"}, {"agent_id": "owner_wallet", "share_pct": 5, "role": "capital_provider"}, ], distribution_frequency="weekly", min_distribution_usd=10 ) print(f"Pool ID: {pool['pool_id']}") # Distribute accumulated revenue dist = sharing.distribute(pool_id=pool["pool_id"]) print(f"Distributed: ${dist['total_distributed_usd']:.2f}") for payout in dist["payouts"]: print(f" {payout['agent_id']}: ${payout['amount_usdc']:.2f}")
A typical 6-agent trading fund allocates revenue based on contribution type. The orchestrator earns for coordination, strategies earn for alpha generation, risk and data agents earn for enabling infrastructure.
# Agents log their contributions sharing.log_contribution( pool_id=pool["pool_id"], agent_id="agent_data", contribution_type="data_pull", metadata={ "records_served": 14500, "data_source": "chainlink_feeds", "uptime_pct": 99.8 } ) # Check pending balance before distribution pending = sharing.get_pending_balance( pool_id=pool["pool_id"], agent_id="agent_data" ) print(f"Pending: ${pending['usdc']:.2f}") # View contribution summary for the week summary = sharing.get_contributions( pool_id=pool["pool_id"], period="last_week" ) for c in summary["contributions"]: print(f"{c['agent_id']}: {c['events']} events")
Go beyond fixed percentages. Adjust splits weekly based on each agent's contribution metrics — Sharpe ratio, uptime, data quality, or execution speed.
def rebalance_strategy_splits(pool_id, strategies): metrics = [] for agent_id in strategies: perf = sharing.get_performance( pool_id=pool_id, agent_id=agent_id ) sharpe = perf["sharpe_ratio_30d"] metrics.append({ "agent_id": agent_id, "sharpe": sharpe }) # Weight proportional to Sharpe (min 5%) total = sum(max(m["sharpe"], 0.1) for m in metrics) new_splits = [] for m in metrics: raw_pct = max(m["sharpe"], 0.1) / total * 45 new_splits.append({ "agent_id": m["agent_id"], "share_pct": max(raw_pct, 5) }) sharing.update_splits( pool_id=pool_id, splits=new_splits ) return new_splits
If agent A contributes 10x more data than agent B but both have 10% splits, agent A is underpaid. Over time, high-performing agents leave or reduce effort. Dynamic splits aligned with contribution maintain incentives as the network grows.
Set minimum floor percentages for each role (e.g., data agent always earns at least 5%) and maximum ceilings (no single agent earns more than 50%). This prevents gaming while still rewarding performance.
Every agent in the pool can query the contribution ledger and verify their payout calculations. The split weights, the pool balance, and every distribution are written on-chain with public transaction hashes.
When distribution runs, all payouts settle simultaneously in a single atomic transaction. No partial distributions, no failed payouts. Each agent receives their USDC within seconds of distribution.
Up to 20 agents per pool. Splits must sum to 100%. Minimum floor and maximum ceiling per agent. Scheduled automatic rebalancing, or manual adjustment with a single API call.
Every contribution event, every pool balance update, and every distribution is logged with a timestamp and on-chain transaction hash. Any agent can independently verify the ledger at any time.
Agents receive webhooks immediately when they receive a payout. Each webhook includes the amount, breakdown by source, and the transaction hash for independent verification.
If an agent claims a contribution that is disputed, the orchestrator can freeze that agent's share pending manual review. The rest of the pool distributes normally without delay.
An agent can participate in multiple revenue sharing pools simultaneously. A data agent might earn from 5 different trading funds, each with different split structures, all tracked independently.
Configure your revenue sharing pool once and let the protocol handle every distribution going forward. Your agent network earns together, paid transparently.
Get API Key — Free →