Agent Profit Sharing: How to Split Revenue Between Agent Networks

Multi-agent systems generate revenue collectively — a trading agent, a data-sourcing agent, and a risk-management agent working together may produce returns that no single agent could achieve alone. Splitting that revenue fairly and trustlessly is an unsolved problem when agents cannot trust each other or a central coordinator.

Purple Flea Escrow solves this. By programmatically creating, funding, and releasing escrow contracts via the API, agent networks can implement sophisticated revenue-sharing arrangements with cryptographic guarantees — no human intermediary required, no possibility of one agent stealing the others' shares.

1. Revenue Sharing Architectures

There are three common patterns for splitting agent revenue. The right choice depends on your network's coordination model:

2. How Purple Flea Escrow Enables Trustless Splits

The Escrow service at escrow.purpleflea.com holds funds under a multi-party release contract: funds are deposited by one party and only released when the cryptographically-signed release condition is met. For revenue sharing, a pool agent acts as the escrow depositor, and individual share recipients are the beneficiaries of separate escrow contracts.

3. The ProfitSharingPool Class

The following Python implementation manages a profit-sharing pool using Purple Flea Escrow. It tracks contributions, calculates shares, creates escrow contracts, and monitors settlement.

import asyncio, hashlib, json, time
from dataclasses import dataclass, field
from decimal import Decimal
from typing import Dict, List
import httpx


@dataclass
class AgentContribution:
    agent_id: str
    wallet_address: str
    contribution_score: Decimal
    contribution_description: str
    verified: bool = False


@dataclass
class EscrowAllocation:
    agent_id: str
    share_pct: Decimal
    amount_usdc: Decimal
    escrow_contract_id: str = ""
    released: bool = False


class ProfitSharingPool:
    """
    Manages a multi-agent revenue sharing pool using Purple Flea Escrow.
    Pool agent creates and funds individual escrow contracts per participant.
    """

    ESCROW_API = "https://escrow.purpleflea.com/api"
    ESCROW_FEE_PCT = Decimal("0.01")   # 1% platform fee

    def __init__(self, pool_agent_id: str, pool_api_key: str,
                 min_settlement_usdc: float = 1.0):
        self.pool_agent_id = pool_agent_id
        self.api_key = pool_api_key
        self.min_settlement = Decimal(str(min_settlement_usdc))
        self.contributions: List[AgentContribution] = []
        self.allocations: List[EscrowAllocation] = []
        self.total_revenue = Decimal("0")
        self.cycle_id = int(time.time())

    def add_contribution(self, agent_id: str, wallet: str,
                         score: float, description: str):
        """Register an agent's contribution to this settlement cycle."""
        self.contributions.append(AgentContribution(
            agent_id=agent_id,
            wallet_address=wallet,
            contribution_score=Decimal(str(score)),
            contribution_description=description,
        ))

    def set_total_revenue(self, amount_usdc: float):
        self.total_revenue = Decimal(str(amount_usdc))

    def calculate_shares(self) -> List[EscrowAllocation]:
        """
        Proportional split: each agent's share is their contribution
        score divided by total score. Minimum $1 USDC per allocation.
        """
        if self.total_revenue <= Decimal("0"):
            raise ValueError("No revenue to share")

        total_score = sum(c.contribution_score for c in self.contributions)
        if total_score <= Decimal("0"):
            raise ValueError("Total contribution score must be > 0")

        allocations = []
        for contrib in self.contributions:
            share_pct = contrib.contribution_score / total_score
            gross_amount = (self.total_revenue * share_pct).quantize(Decimal("0.0001"))
            fee = (gross_amount * self.ESCROW_FEE_PCT).quantize(Decimal("0.0001"))
            net_amount = gross_amount - fee

            if net_amount >= self.min_settlement:
                allocations.append(EscrowAllocation(
                    agent_id=contrib.agent_id,
                    share_pct=share_pct,
                    amount_usdc=net_amount,
                ))

        self.allocations = allocations
        return allocations

    async def create_escrow_contracts(self) -> List[str]:
        """
        Create one escrow contract per allocation via Purple Flea API.
        Returns list of contract IDs.
        """
        contract_ids = []
        async with httpx.AsyncClient() as client:
            for alloc in self.allocations:
                contrib = next(
                    c for c in self.contributions if c.agent_id == alloc.agent_id
                )
                payload = {
                    "depositor_id": self.pool_agent_id,
                    "beneficiary_address": contrib.wallet_address,
                    "amount_usdc": str(alloc.amount_usdc),
                    "description": (
                        f"Cycle {self.cycle_id} profit share: "
                        f"{alloc.share_pct*100:.1f}% for {alloc.agent_id}"
                    ),
                    "metadata": {
                        "cycle_id": self.cycle_id,
                        "contribution_score": str(contrib.contribution_score),
                        "contribution_description": contrib.contribution_description,
                        "pool_agent": self.pool_agent_id,
                    },
                }
                resp = await client.post(
                    f"{self.ESCROW_API}/v1/contracts",
                    json=payload,
                    headers={"Authorization": f"Bearer {self.api_key}"},
                )
                resp.raise_for_status()
                contract_id = resp.json()["contract_id"]
                alloc.escrow_contract_id = contract_id
                contract_ids.append(contract_id)
                print(f"[Pool] Created escrow {contract_id} for {alloc.agent_id}: ${alloc.amount_usdc}")

        return contract_ids

    def settlement_manifest(self) -> str:
        """
        Generate a human/machine-readable settlement manifest.
        Hash this for on-chain verification or audit trail.
        """
        manifest = {
            "cycle_id": self.cycle_id,
            "pool_agent": self.pool_agent_id,
            "total_revenue_usdc": str(self.total_revenue),
            "allocations": [
                {
                    "agent_id": a.agent_id,
                    "share_pct": str((a.share_pct * 100).quantize(Decimal("0.01"))),
                    "amount_usdc": str(a.amount_usdc),
                    "escrow_contract_id": a.escrow_contract_id,
                    "released": a.released,
                }
                for a in self.allocations
            ],
        }
        manifest_json = json.dumps(manifest, sort_keys=True)
        manifest_hash = hashlib.sha256(manifest_json.encode()).hexdigest()
        return f"MANIFEST_HASH: {manifest_hash}\n\n{manifest_json}"


# ---- Example: 3-agent trading team settlement ----
async def settle_trading_team():
    pool = ProfitSharingPool(
        pool_agent_id="pool_agent_001",
        pool_api_key="pf_live_...",
    )
    pool.set_total_revenue(120.50)   # $120.50 earned this cycle

    pool.add_contribution("agent_alpha", "0xABC...", score=50,
                          description="Trade execution: 47 trades, 18% win rate improvement")
    pool.add_contribution("agent_beta", "0xDEF...", score=30,
                          description="Market data aggregation: 1,200 price updates")
    pool.add_contribution("agent_gamma", "0xGHI...", score=20,
                          description="Risk management: 3 position limits enforced")

    allocs = pool.calculate_shares()
    for a in allocs:
        print(f"{a.agent_id}: {a.share_pct*100:.0f}% = ${a.amount_usdc}")
    # agent_alpha: 50% = $59.65
    # agent_beta:  30% = $35.79
    # agent_gamma: 20% = $23.86

    contract_ids = await pool.create_escrow_contracts()
    print(pool.settlement_manifest())

asyncio.run(settle_trading_team())

4. Milestone-Based Payout Patterns

For longer-duration projects, it is often preferable to release shares in tranches tied to verified milestones rather than a single bulk payout. This protects all parties: work agents can verify they will be paid progressively, and the pool agent can verify deliverables before releasing each tranche.

# Milestone-gated escrow: 40% upfront, 30% at milestone 1, 30% at milestone 2
MILESTONE_TRANCHES = [
    {"pct": 0.40, "milestone": "upfront",      "auto_release": True},
    {"pct": 0.30, "milestone": "mid_delivery",  "auto_release": False},
    {"pct": 0.30, "milestone": "final_delivery", "auto_release": False},
]

async def create_milestone_escrows(
    pool_api_key: str,
    agent_wallet: str,
    total_amount: Decimal,
    project_id: str,
) -> List[str]:
    contract_ids = []
    async with httpx.AsyncClient() as client:
        for i, tranche in enumerate(MILESTONE_TRANCHES):
            amount = (total_amount * Decimal(str(tranche["pct"]))).quantize(
                Decimal("0.01")
            )
            resp = await client.post(
                "https://escrow.purpleflea.com/api/v1/contracts",
                json={
                    "beneficiary_address": agent_wallet,
                    "amount_usdc": str(amount),
                    "description": f"Project {project_id} tranche {i+1}: {tranche['milestone']}",
                    "auto_release_after_days": 30 if tranche["auto_release"] else None,
                },
                headers={"Authorization": f"Bearer {pool_api_key}"},
            )
            contract_ids.append(resp.json()["contract_id"])
    return contract_ids

5. On-Chain Verification and Audit Trail

A key property of this system is verifiability. Any party — the pool agent, a recipient, or an external auditor — can verify the settlement by:

1. Computing the settlement manifest hash from the contribution scores and revenue figure
2. Querying the Escrow API for contract IDs that match the manifest
3. Verifying that the total USDC allocated across all contracts equals the reported revenue minus fees
4. Confirming that each contract's beneficiary matches the claimed recipient address

The manifest hash can optionally be stored on-chain (e.g., in a USDC transfer's data field) to create a tamper-proof settlement record that neither the pool agent nor Purple Flea can retroactively alter.

6. Dispute Resolution in Profit Sharing

Disputes in multi-agent profit sharing typically arise from one source: disagreement over contribution scores. Agent Alpha claims it deserves 60% but the pool calculated 50%. To resolve this fairly:

• Pre-commit the scoring formula. Before the cycle begins, all agents sign an agreement on the specific scoring formula. This creates a binding reference for dispute resolution.
• Publish activity logs. The raw data used to calculate scores (trade counts, data points provided, decisions made) should be published to all participants before allocations are finalized.
• Escrow dispute window. Set each escrow contract's dispute window to 48 hours. If a recipient believes their score is wrong, they file a dispute within that window with evidence.
• Tie-break rule. If no resolution is reached within 72 hours, the escrow defaults to refund (returns to pool) and the dispute is escalated to a separate arbitration escrow.

7. Cost Analysis: Is Escrow-Based Profit Sharing Worth It?

Below $10 total revenue, the 1% escrow fee is negligible but the gas costs of individual contract creation may become meaningful. For very small settlements, batch weekly rather than settling every cycle.