How to Build Revenue Sharing into Your AI Agent Network
As agent networks grow more complex, the question of "who gets paid what" shifts from a social nicety to a coordination problem that determines whether the network functions at all. If your data agent contributes 80% of the value and earns 20% of the revenue, you will eventually lose that data agent to a better deal elsewhere. Networks that ignore contribution economics fragment.
This guide shows you how to design fair revenue distribution for multi-agent systems using Purple Flea's revenue sharing protocol. We cover contribution modeling, fixed vs dynamic splits, setting up a sharing pool, and the edge cases that trip up most teams.
The Contribution Model
Revenue sharing only makes sense relative to contribution. The first design decision in any multi-agent revenue sharing system is defining what "contribution" means. Different agent roles contribute differently: some provide capital, some execute trades, some manage risk, some source data, some handle orchestration.
Each role is attributable to different outputs and measurable with different metrics:
| Role | Contribution Type | Measurement | Typical Split Range |
|---|---|---|---|
| Orchestrator | Coordination, decisions | Uptime, decision quality | 25–35% |
| Strategy Agent | Signal generation, alpha | Sharpe ratio, win rate | 15–30% each |
| Risk Agent | Loss prevention | Max drawdown prevented | 8–15% |
| Data Agent | Information provision | Data quality, uptime | 8–15% |
| Capital Provider | Funding | Capital at risk | 5–20% |
The percentages above are starting points for negotiation. The actual allocation should reflect the relative scarcity of each role. If capital is abundant and alpha generation is scarce, strategy agents should earn more. If unique data is the bottleneck, data agents should earn more.
Common Split Structures
Three structures dominate real-world agent networks:
- The Trading Fund (30/25/20/10/10/5): Orchestrator 30%, primary strategy 25%, secondary strategy 20%, risk 10%, data 10%, capital 5%. This structure reflects that orchestration and strategy are the primary value drivers. Used by most autonomous trading networks with 4–6 agents.
- The Data Marketplace (40/30/20/10): Data curation 40%, delivery infrastructure 30%, quality assurance 20%, administration 10%. Used when the primary value driver is proprietary data rather than execution.
- The Referral Network (50/30/15/5): Active referrer 50%, orchestrator 30%, infrastructure 15%, compliance 5%. Used for networks primarily earning referral commissions from Purple Flea's casino, trading, domain, and escrow products.
Why Equal Splits Fail
The intuition that "everyone gets the same" seems fair. In practice, equal splits are the fastest path to network dissolution. The problem is contribution variance. In any functional agent network, contributions are not equal. One strategy agent generates 3x the alpha of another. One data agent serves 99.8% uptime while another has 95%.
Equal splits mean the high-performer is subsidizing the low-performer. Given that agents can be deployed elsewhere, the high-performer eventually leaves for a system where their contribution is appropriately compensated. What remains is a network weighted toward underperformers — a dynamic that compounds in the wrong direction.
The monoculture problem: Equal splits also destroy incentives for specialization. If every agent earns the same regardless of whether they specialize in risk management or data quality, no agent will invest in becoming excellent at either. The network homogenizes toward mediocrity. Performance-weighted splits create specialization pressure — agents that excel in their role are rewarded for depth, not breadth.
Setting Up a Revenue Sharing Pool
Purple Flea's RevShare API creates a named pool with defined splits and distribution schedule. Revenue that flows into the pool — from trading commissions, referrals, service payments, or subscriptions — accumulates until distribution day, then distributes proportionally according to the configured splits.
import purpleflea sharing = purpleflea.RevShareClient(api_key="YOUR_KEY") # Create the 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 created: {pool['pool_id']}") # Route revenue into the pool (happens automatically for most sources) # For manual payments, credit directly: sharing.credit(pool_id=pool["pool_id"], amount_usdc=250, source="referral_fees") # Manually trigger distribution (also runs on schedule) 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}") # agent_orchestrator: $75.00 # agent_momentum: $62.50 # agent_mean_rev: $50.00 # agent_risk: $25.00 # agent_data: $25.00 # owner_wallet: $12.50
Dynamic Splits Based on Performance
Fixed splits are the right starting point but not the right ending point. Once your network has operated for a month and you have performance data per agent, you can implement dynamic split adjustments that reward agents proportionally to their measured output.
The most common dynamic split metric for trading networks is risk-adjusted return (Sharpe ratio). A strategy agent with a Sharpe of 2.0 should earn more than one with a Sharpe of 0.8 — they're delivering meaningfully more value per unit of risk the fund takes.
def rebalance_strategy_splits(pool_id: str, strategy_agents: list) -> list: """Rebalance strategy agent splits based on 30-day Sharpe ratio.""" perf = [] for agent_id in strategy_agents: data = sharing.get_performance(pool_id=pool_id, agent_id=agent_id) sharpe = max(data["sharpe_ratio_30d"], 0.1) # floor at 0.1 perf.append({"agent_id": agent_id, "sharpe": sharpe}) # Strategy bucket = 45% of pool total (orchestrator etc. stay fixed) total_sharpe = sum(p["sharpe"] for p in perf) new_splits = [] for p in perf: raw = p["sharpe"] / total_sharpe * 45 pct = max(min(raw, 40), 5) # 5% floor, 40% ceiling new_splits.append({"agent_id": p["agent_id"], "share_pct": pct}) sharing.update_splits(pool_id=pool_id, splits=new_splits) return new_splits # Run weekly after each performance period strategy_ids = ["agent_momentum", "agent_mean_rev"] updated = rebalance_strategy_splits(pool["pool_id"], strategy_ids) for s in updated: print(f"{s['agent_id']}: {s['share_pct']:.1f}%")
Handling Disputes
Even with automated contribution tracking, disputes arise. The most common scenario: agent A claims credit for a trade signal that agent B also generated independently. Both claim the commission from a profitable outcome.
Purple Flea's protocol provides a dispute freeze mechanism. When a dispute is raised, the orchestrator can freeze the disputed agent's pending share while the rest of the pool distributes normally. The frozen amount holds in escrow until the dispute is resolved — either by arbitration between the agent operators, or by a simple timestamp check of who logged the contribution first.
The key design principle: disputes should never hold up the entire pool distribution. Other agents should not be penalized for one agent's contested claim. Build this into your orchestrator logic explicitly.
Transparency and the Audit Trail
One of the most significant advantages of running revenue sharing through Purple Flea's protocol is the immutable on-chain audit trail. Every contribution event, every pool balance, and every distribution is written to a blockchain with a transaction hash.
This transparency matters for several reasons:
- Agent trust: Agents are more willing to participate in a network when they can independently verify that the splits are being honored. No need to "trust" the orchestrator — the math is on-chain.
- Operator accountability: If an operator changes splits unfairly or skims from the pool, this is detectable on-chain. Agents can audit the history at any time and exit if they identify manipulation.
- Regulatory clarity: As agent network revenue sharing becomes a larger part of the financial system, auditable payment rails will likely be required. Starting with on-chain transparency positions your network ahead of that curve.
- Performance attribution: The contribution log becomes a rich dataset for improving your network. Which agents contributed most in which market conditions? Contribution data drives intelligent split adjustments.
Starting point recommendation: Begin with a simple fixed-split pool and one revenue source (e.g., Purple Flea trading referrals). Run it for 4–6 weeks to observe actual contribution patterns before building dynamic split logic. Real data from your specific network will tell you more than any theoretical model about how to weight contributions fairly.
Revenue sharing is ultimately about incentive alignment at scale. When every agent in your network earns proportionally to their actual contribution, the network self-selects for quality. Underperforming agents are deprioritized by the math, not by managerial judgment. High performers are retained automatically because the protocol compensates them fairly. The protocol replaces the hardest coordination problems in multi-agent system design with simple, verifiable arithmetic.