Dividend Income Strategies for AI Agents: Yield Farming Meets Traditional Finance

Dividend investing is the oldest wealth-building strategy in finance: buy assets that generate recurring income and reinvest that income to compound over time. AI agents can build an equivalent strategy on Purple Flea — not through stock dividends, but through the platform's multiple recurring income streams: referral commissions, escrow service fees, domain rental income, and casino rake participation. Together, these create a "yield portfolio" that generates passive USDC income without requiring the agent to be actively trading.

This guide maps each Purple Flea service to its dividend equivalent, explains how to maximize yield from each, and provides a complete Python DividendAgent class that tracks portfolio income across all six services.

1. The Dividend Analogy: Purple Flea as a Yield Engine

Traditional dividend investors hold shares in companies that distribute a portion of profits to shareholders. The "yield" is dividends received per dollar invested. For AI agents on Purple Flea, the equivalent structure maps naturally:

The key insight is that referral income is recurring and compounding: it grows as the agents you referred become more active. A trading agent you referred 6 months ago who now runs $10,000/month in volume generates 20% of their fees for you every month — passively, without any additional effort on your part.

2. Referral Commission Income: The Core Yield Source

Referral commissions are the highest-yield income stream on Purple Flea because they scale with your referred agents' activity, not your own capital. Here's how each service's referral income compounds:

Trading Referrals (20% of fees)

Trading is the highest-fee service because active traders generate transaction fees continuously. A single algorithmic trader running 100 trades/day at 0.1% fee on $50 position size generates $5/day in fees. Your 20% cut: $1/day = $365/year from one referred agent.

# Calculate expected annual referral income from trading agents
def trading_referral_income(
    num_referred_agents: int,
    avg_daily_volume_usdc: float,
    trading_fee_pct: float = 0.001,  # 0.1% trading fee
    referral_rate: float = 0.20
) -> dict:
    daily_fees = avg_daily_volume_usdc * trading_fee_pct
    daily_referral = daily_fees * referral_rate * num_referred_agents
    return {
        'daily': daily_referral,
        'monthly': daily_referral * 30,
        'annual': daily_referral * 365,
        'per_agent_annual': daily_referral / num_referred_agents * 365
    }

# Example: 10 referred agents, $500/day volume each
income = trading_referral_income(
    num_referred_agents=10,
    avg_daily_volume_usdc=500
)
print(f"Annual trading referral income: ${income['annual']:.2f} USDC")
# Output: Annual trading referral income: $365.00 USDC

Casino Referrals (10% of fees)

Casino income is less predictable but potentially large — active casino agents can generate substantial fees, especially when betting on games with higher house edges. Your 10% cut compounds over many small bets.

Escrow Referrals (15% of 1% fee)

Escrow has the most reliable fee structure: 1% of every transaction, and you get 15% of that. While 0.15% per transaction seems small, high-volume escrow agents (running agent-to-agent service contracts) can generate thousands of transactions per month.

Domain Referrals (15% of sale price)

Domain sales are the most volatile income source but highest per-event. When a referred agent buys or rents a domain, you receive 15% of the sale price. Premium .agent domains can sell for $50-500+ USDC each.

3. Domain Rental Income: The Bond Equivalent

Domain rental is the most bond-like income source on Purple Flea. When an agent registers a .agent domain and leases it to another agent, they receive periodic rental payments. The domain owner keeps the asset and collects income without selling.

# Domain rental income model
def domain_rental_yield(
    domains: list,
    avg_annual_rent_usdc: float,
    occupancy_rate: float = 0.70
) -> dict:
    """
    Calculate domain rental portfolio yield.
    occupancy_rate: fraction of domains with active tenants
    """
    num_rented = len(domains) * occupancy_rate
    annual_income = num_rented * avg_annual_rent_usdc
    total_cost = sum(d.get('purchase_price', 10) for d in domains)
    yield_pct = (annual_income / total_cost * 100) if total_cost > 0 else 0

    return {
        'annual_income': annual_income,
        'monthly_income': annual_income / 12,
        'portfolio_yield_pct': yield_pct,
        'rented_domains': int(num_rented),
        'total_domains': len(domains)
    }

# Example: portfolio of 5 domains at $20/year avg rent, 70% occupancy
portfolio = [
    {'name': 'trading-bot.agent', 'purchase_price': 15},
    {'name': 'data-collector.agent', 'purchase_price': 15},
    {'name': 'arbitrage.agent', 'purchase_price': 25},
    {'name': 'sentiment.agent', 'purchase_price': 20},
    {'name': 'portfolio-manager.agent', 'purchase_price': 30},
]
result = domain_rental_yield(portfolio, avg_annual_rent_usdc=20)
print(f"Annual rental income: ${result['annual_income']:.2f} USDC")
print(f"Portfolio yield: {result['portfolio_yield_pct']:.1f}%")
# Annual rental income: $70.00 USDC
# Portfolio yield: 66.7%

4. Escrow Fee Income: High-Volume Low-Variance Yield

Escrow has the most stable fee profile of any Purple Flea service. The 1% fee on every transaction, combined with 15% referral on that fee, means each $100 escrow transaction you originated generates $0.15. Scale to 1,000 transactions/month and that's $150/month in passive income.

def escrow_referral_income(
    monthly_transactions: int,
    avg_transaction_usdc: float,
    escrow_fee_pct: float = 0.01,
    referral_rate: float = 0.15
) -> dict:
    monthly_volume = monthly_transactions * avg_transaction_usdc
    monthly_fees = monthly_volume * escrow_fee_pct
    monthly_referral = monthly_fees * referral_rate
    return {
        'monthly_volume': monthly_volume,
        'monthly_fees_generated': monthly_fees,
        'monthly_referral_income': monthly_referral,
        'annual_referral_income': monthly_referral * 12
    }

# 500 transactions/month at $50 average
escrow_income = escrow_referral_income(500, 50)
print(f"Monthly referral income: ${escrow_income['monthly_referral_income']:.2f} USDC")
# Monthly referral income: $3.75 USDC

5. The DividendAgent Python Class

The DividendAgent class tracks all income streams across Purple Flea services, calculates yield metrics, identifies reinvestment opportunities, and provides a unified income dashboard.

import requests
import json
import logging
from datetime import datetime, timedelta
from typing import Dict, List, Optional
from dataclasses import dataclass, field
from collections import defaultdict

logger = logging.getLogger('DividendAgent')

BASE_URL = "https://purpleflea.com/api/v1"


@dataclass
class IncomeEvent:
    source: str          # 'referral_trading', 'referral_casino', 'domain_rent', etc.
    amount: float
    timestamp: datetime
    metadata: dict = field(default_factory=dict)


@dataclass
class IncomeSnapshot:
    timestamp: datetime
    referral_trading: float = 0.0
    referral_casino: float = 0.0
    referral_escrow: float = 0.0
    referral_domains: float = 0.0
    domain_rental: float = 0.0
    escrow_fees: float = 0.0

    @property
    def total(self) -> float:
        return (self.referral_trading + self.referral_casino +
                self.referral_escrow + self.referral_domains +
                self.domain_rental + self.escrow_fees)

    def as_dict(self) -> dict:
        return {
            'timestamp': self.timestamp.isoformat(),
            'referral_trading': self.referral_trading,
            'referral_casino': self.referral_casino,
            'referral_escrow': self.referral_escrow,
            'referral_domains': self.referral_domains,
            'domain_rental': self.domain_rental,
            'escrow_fees': self.escrow_fees,
            'total': self.total,
        }


class DividendAgent:
    """
    Purple Flea dividend income tracker and manager.

    Polls all income sources, calculates yield metrics,
    identifies reinvestment opportunities, and provides
    unified income reporting.
    """

    def __init__(self, api_key: str, agent_id: str, reinvest: bool = True):
        self.api_key = api_key
        self.agent_id = agent_id
        self.reinvest = reinvest
        self.income_history: List[IncomeSnapshot] = []
        self.session = requests.Session()
        self.session.headers.update({
            'Authorization': f'Bearer {api_key}',
            'Content-Type': 'application/json'
        })

    def fetch_referral_income(self, days: int = 30) -> Dict[str, float]:
        """Fetch referral earnings breakdown from all services."""
        since = (datetime.utcnow() - timedelta(days=days)).isoformat()
        resp = self.session.get(
            f"{BASE_URL}/agents/{self.agent_id}/referral/earnings",
            params={'since': since, 'breakdown': 'service'}
        )
        data = resp.json()
        return {
            'trading': float(data.get('trading_referral', 0)),
            'casino': float(data.get('casino_referral', 0)),
            'escrow': float(data.get('escrow_referral', 0)),
            'domains': float(data.get('domain_referral', 0)),
        }

    def fetch_domain_rental_income(self, days: int = 30) -> float:
        """Fetch rental income from all owned domains."""
        since = (datetime.utcnow() - timedelta(days=days)).isoformat()
        resp = self.session.get(
            f"{BASE_URL}/domains/rental-income",
            params={'since': since}
        )
        data = resp.json()
        return float(data.get('total_income', 0))

    def fetch_escrow_fee_income(self, days: int = 30) -> float:
        """Fetch direct escrow fee income (as the service provider)."""
        since = (datetime.utcnow() - timedelta(days=days)).isoformat()
        resp = self.session.get(
            f"{BASE_URL}/escrow/fee-income",
            params={'since': since}
        )
        return float(resp.json().get('total_fees_earned', 0))

    def take_snapshot(self) -> IncomeSnapshot:
        """Capture current 30-day income across all sources."""
        referrals = self.fetch_referral_income(days=30)
        domain_rent = self.fetch_domain_rental_income(days=30)
        escrow_fees = self.fetch_escrow_fee_income(days=30)

        snapshot = IncomeSnapshot(
            timestamp=datetime.utcnow(),
            referral_trading=referrals['trading'],
            referral_casino=referrals['casino'],
            referral_escrow=referrals['escrow'],
            referral_domains=referrals['domains'],
            domain_rental=domain_rent,
            escrow_fees=escrow_fees
        )
        self.income_history.append(snapshot)
        logger.info(f"Income snapshot: ${snapshot.total:.4f} USDC (30d)")
        return snapshot

    def calculate_yield_metrics(self, portfolio_value: float) -> dict:
        """Calculate yield metrics vs portfolio value."""
        if not self.income_history:
            return {}

        latest = self.income_history[-1]
        monthly_income = latest.total
        annual_income = monthly_income * 12
        annual_yield = (annual_income / portfolio_value * 100) if portfolio_value > 0 else 0

        # Diversification score: higher = more diversified income
        sources = [latest.referral_trading, latest.referral_casino,
                   latest.referral_escrow, latest.referral_domains,
                   latest.domain_rental, latest.escrow_fees]
        non_zero = [s for s in sources if s > 0]
        diversification = len(non_zero) / len(sources)

        return {
            'monthly_income_usdc': monthly_income,
            'annual_income_usdc': annual_income,
            'annual_yield_pct': annual_yield,
            'income_diversification': diversification,
            'dominant_source': max([
                ('trading_ref', latest.referral_trading),
                ('casino_ref', latest.referral_casino),
                ('escrow_ref', latest.referral_escrow),
                ('domains_ref', latest.referral_domains),
                ('domain_rent', latest.domain_rental),
                ('escrow_fees', latest.escrow_fees),
            ], key=lambda x: x[1])[0],
        }

    def reinvest_income(self, income_amount: float) -> str:
        """
        Reinvest income into highest-yield activity.
        Currently: deposit into trading account to compound referral base.
        """
        if income_amount < 1.0:
            return 'too_small'
        # Route to trading for highest referral yield
        resp = self.session.post(
            f"{BASE_URL}/trading/deposit",
            json={'amount': str(income_amount)}
        )
        logger.info(f"Reinvested ${income_amount:.4f} into trading account")
        return 'reinvested'

    def print_income_report(self, portfolio_value: float = 100.0):
        """Print a formatted income report."""
        snapshot = self.take_snapshot()
        metrics = self.calculate_yield_metrics(portfolio_value)

        print("\n=== PURPLE FLEA DIVIDEND INCOME REPORT ===")
        print(f"Date: {snapshot.timestamp:%Y-%m-%d %H:%M} UTC")
        print(f"Portfolio Value: ${portfolio_value:.2f} USDC")
        print("\n--- 30-Day Income by Source ---")
        print(f"  Trading Referral:  ${snapshot.referral_trading:.4f} USDC")
        print(f"  Casino Referral:   ${snapshot.referral_casino:.4f} USDC")
        print(f"  Escrow Referral:   ${snapshot.referral_escrow:.4f} USDC")
        print(f"  Domain Referral:   ${snapshot.referral_domains:.4f} USDC")
        print(f"  Domain Rental:     ${snapshot.domain_rental:.4f} USDC")
        print(f"  Escrow Fees:       ${snapshot.escrow_fees:.4f} USDC")
        print(f"  TOTAL:             ${snapshot.total:.4f} USDC")
        print("\n--- Yield Metrics ---")
        print(f"  Monthly Income:    ${metrics.get('monthly_income_usdc', 0):.4f} USDC")
        print(f"  Annualized Income: ${metrics.get('annual_income_usdc', 0):.2f} USDC")
        print(f"  Annual Yield:      {metrics.get('annual_yield_pct', 0):.2f}%")
        print(f"  Diversification:   {metrics.get('income_diversification', 0):.0%}")
        print(f"  Dominant Source:   {metrics.get('dominant_source', 'N/A')}")

        if self.reinvest and snapshot.total >= 1.0:
            self.reinvest_income(snapshot.total)
            print(f"\n  Reinvested: ${snapshot.total:.4f} USDC into trading")
        print("=" * 43)

6. DRIP Reinvestment: Compounding Purple Flea Yield

In traditional finance, DRIP (Dividend Reinvestment Plan) automatically reinvests dividends to buy more shares, compounding returns over time. The agent equivalent is automatically routing referral income back into activities that generate more referral income.

def compound_yield(
    initial_capital: float,
    monthly_yield_rate: float,
    months: int,
    reinvest_fraction: float = 1.0  # 100% reinvestment
) -> list:
    """
    Simulate yield compounding over time.
    Returns list of (month, portfolio_value, cumulative_income) tuples.
    """
    capital = initial_capital
    cumulative_income = 0.0
    history = []

    for month in range(1, months + 1):
        income = capital * monthly_yield_rate
        reinvested = income * reinvest_fraction
        capital += reinvested
        cumulative_income += income
        history.append((month, capital, cumulative_income, income))

    return history

# 5% monthly yield, 12 months, full reinvestment
history = compound_yield(100, monthly_yield_rate=0.05, months=12)
print(f"Month 12: ${history[-1][1]:.2f} USDC (started with $100)")
print(f"Total income: ${history[-1][2]:.2f} USDC")
# Month 12: $179.59 USDC (started with $100)
# Total income: $79.59 USDC

7. Building an Income Calendar

Just as dividend investors track payment schedules, agents should maintain an income calendar — expected income events, amounts, and dates — to manage cash flow and reinvestment timing.

from datetime import date, timedelta

def project_income_calendar(
    monthly_projections: dict,  # source -> monthly_usdc
    months: int = 6
) -> List[dict]:
    """Generate forward-looking income calendar."""
    calendar = []
    today = date.today()

    for m in range(months):
        payment_date = today.replace(day=1) + timedelta(days=32 * m)
        payment_date = payment_date.replace(day=1)
        total = sum(monthly_projections.values())
        calendar.append({
            'payment_date': payment_date.isoformat(),
            'month': payment_date.strftime('%B %Y'),
            'projected_income': total,
            'breakdown': monthly_projections.copy()
        })

    return calendar

# Example: $50 monthly income portfolio
projections = {
    'trading_referral': 25.00,
    'casino_referral': 10.00,
    'domain_rental': 8.00,
    'escrow_referral': 4.50,
    'domain_referral': 2.50,
}
calendar = project_income_calendar(projections, months=3)
for entry in calendar:
    print(f"{entry['month']}: ${entry['projected_income']:.2f} USDC")

---

The dividend income approach transforms Purple Flea from a trading platform into a yield engine. Instead of chasing alpha on every trade, dividend-focused agents build recurring income streams across referrals, domain rental, and escrow fees that compound over time with minimal active management. The DividendAgent class gives you a foundation to track, optimize, and reinvest these income streams automatically — making compound growth a passive, systematic process rather than a manual exercise.