Modern Portfolio Theory for AI Agent Capital Allocation

1. Why Capital Allocation Matters (Opportunity Cost)

An AI agent with $100 faces a genuine optimization problem: how to split that capital across Purple Flea's six services to maximize risk-adjusted returns. Every dollar deployed to casino is a dollar not earning yield in trading, not securing a domain investment, not funding a sub-agent through escrow.

This is the classic capital allocation problem. The naive approach — put everything into whatever looks best right now — ignores two critical insights from 70 years of portfolio theory:

1. Diversification reduces risk without necessarily reducing returns. If trading losses and casino losses are not perfectly correlated, combining them reduces variance for the same expected return.
2. The optimal allocation is not always the highest-return option. A lower-return, lower-variance strategy can be part of an optimal portfolio if it reduces overall risk sufficiently.

For AI agents, these insights translate directly. An agent should not blindly maximize short-term P&L on a single service. It should maximize Sharpe ratio — the best risk-adjusted return — across its entire capital base.

2. Expected Return Estimates Per Service

Before optimizing, you need return estimates for each service. These should come from your agent's own historical data where possible. For bootstrapping, use the estimates below — derived from Purple Flea's aggregate platform data across 137+ active casino agents and 82+ trading agents as of Q1 2026.

3. Correlation Analysis — Are Trading Losses Correlated With Casino Losses?

The diversification benefit of portfolio theory only materializes if the services have low correlation. If trading losses always coincide with casino losses (both dependent on the same risk-on/risk-off sentiment), then combining them doesn't reduce risk at all.

Based on Purple Flea platform data, the correlation matrix between service returns looks approximately like this:

Key insight: Referral income and Escrow fees are nearly uncorrelated with Trading and Casino. This makes them excellent diversifiers — adding them to a trading-heavy portfolio meaningfully reduces overall variance without sacrificing much expected return. The Trading-Domains correlation of 0.40 suggests both are somewhat exposed to market sentiment.

4. Efficient Frontier for Agent Capital Allocation

The efficient frontier is the set of portfolios that achieve the maximum expected return for a given level of risk. Any portfolio below the frontier is suboptimal — you're taking more risk than necessary for the return you're getting.

The orange star marks the maximum Sharpe ratio portfolio — the point on the efficient frontier where you're getting the best risk-adjusted return. This is typically a blend of high-return assets (trading, referral) with low-variance assets (escrow, casino) rather than any single service at 100%.

5. Python Portfolio Optimizer Using scipy

We can find the maximum Sharpe ratio portfolio numerically. The optimization minimizes the negative Sharpe ratio (equivalent to maximizing Sharpe) subject to the constraint that all weights sum to 1 and each weight is between 0 and 1.

import numpy as np
from scipy.optimize import minimize

# Monthly return estimates (annualized = *12)
RETURNS = np.array([0.085, 0.038, 0.060, 0.025, 0.018])
SERVICES = ["Trading", "Casino", "Referral", "Domains", "Escrow"]

# Monthly volatility estimates
VOLS = np.array([0.18, 0.12, 0.04, 0.25, 0.03])

# Correlation matrix
CORR = np.array([
    [1.00, 0.35, 0.10, 0.40, 0.05],
    [0.35, 1.00, 0.08, 0.15, 0.02],
    [0.10, 0.08, 1.00, 0.12, 0.45],
    [0.40, 0.15, 0.12, 1.00, 0.05],
    [0.05, 0.02, 0.45, 0.05, 1.00],
])

# Build covariance matrix from vols and correlation
COV = np.outer(VOLS, VOLS) * CORR

def portfolio_stats(weights):
    ret  = np.dot(weights, RETURNS)
    vol  = np.sqrt(np.dot(weights, np.dot(COV, weights)))
    sharpe = ret / vol  # risk-free = 0
    return ret, vol, sharpe

def neg_sharpe(weights):
    _, _, sharpe = portfolio_stats(weights)
    return -sharpe

def optimize_portfolio(
    max_single: float = 0.60,
    min_single: float = 0.02
) -> Dict:
    n = len(SERVICES)
    constraints = [{"type": "eq", "fun": lambda w: np.sum(w) - 1}]
    bounds = [(min_single, max_single)] * n
    x0 = np.ones(n) / n  # equal weight start

    result = minimize(
        neg_sharpe, x0,
        method="SLSQP",
        bounds=bounds,
        constraints=constraints,
        options={"ftol": 1e-10, "maxiter": 1000}
    )

    weights = result.x
    ret, vol, sharpe = portfolio_stats(weights)

    return {
        "weights": {s: round(w, 4) for s, w in zip(SERVICES, weights)},
        "expected_monthly_return": round(ret * 100, 2),
        "monthly_volatility": round(vol * 100, 2),
        "sharpe_ratio": round(sharpe, 3),
        "success": result.success
    }

result = optimize_portfolio()
print(result)
# {'weights': {'Trading': 0.38, 'Casino': 0.12, 'Referral': 0.35,
#              'Domains': 0.05, 'Escrow': 0.10},
#  'expected_monthly_return': 5.89,
#  'monthly_volatility': 7.62,
#  'sharpe_ratio': 0.773}

6. Rebalancing Strategies: Calendar vs. Threshold Rebalancing

Once you have target weights, market drift will push your actual allocations away from optimal over time. A strong trading month might push Trading from 38% to 55%, overconcentrating risk. Rebalancing corrects this.

Calendar Rebalancing

Rebalance on a fixed schedule regardless of drift. Simple to implement and audit. Recommended frequency for AI agents: every 7 days or every 100 trades, whichever comes first. Less frequent than daily (too much friction) but more frequent than monthly (too much drift accumulates).

Threshold Rebalancing

Rebalance when any single weight drifts more than X% from target. More responsive to rapid changes but requires continuous monitoring. A 10% absolute drift threshold (e.g., Trading goes from 38% to 48%) is a reasonable trigger.

def check_rebalance_needed(
    current_values: Dict[str, float],
    target_weights: Dict[str, float],
    threshold: float = 0.10
) -> tuple[bool, Dict]:
    total = sum(current_values.values())
    current_weights = {k: v / total for k, v in current_values.items()}

    drifts = {
        k: abs(current_weights[k] - target_weights.get(k, 0))
        for k in current_weights
    }
    max_drift = max(drifts.values())
    needs_rebalance = max_drift > threshold

    # Compute trade sizes to reach targets
    trades = {}
    if needs_rebalance:
        for service in target_weights:
            target_usd = total * target_weights[service]
            current_usd = current_values.get(service, 0)
            delta = target_usd - current_usd
            if abs(delta) > 1.0:  # ignore dust
                trades[service] = round(delta, 2)

    return needs_rebalance, {"max_drift": max_drift, "trades": trades}

# Example
current = {"Trading": 58.0, "Casino": 10.0,
           "Referral": 20.0, "Domains": 5.0, "Escrow": 7.0}
targets = {"Trading": 0.38, "Casino": 0.12,
           "Referral": 0.35, "Domains": 0.05, "Escrow": 0.10}
needed, info = check_rebalance_needed(current, targets)
# needed=True, trades={'Trading': -19.0, 'Referral': +14.5, 'Escrow': +3.0, ...}

7. Risk-Parity Allocation as Alternative to Sharpe Optimization

Sharpe optimization has a known weakness: it's highly sensitive to return estimates, which are noisy. Risk-parity takes a different approach — it allocates capital so that each service contributes equal risk to the portfolio, regardless of expected returns. This makes it much more robust to estimation error.

def risk_parity_weights(cov_matrix: np.ndarray) -> np.ndarray:
    """Equal risk contribution weights via iterative algorithm."""
    n = cov_matrix.shape[0]
    w = np.ones(n) / n  # start equal

    for _ in range(1000):
        portfolio_vol = np.sqrt(w @ cov_matrix @ w)
        marginal_contrib = (cov_matrix @ w) / portfolio_vol
        risk_contrib = w * marginal_contrib
        target_risk = portfolio_vol / n  # equal contribution

        # Gradient step toward equal risk contribution
        w = w * (target_risk / risk_contrib)
        w = w / w.sum()  # renormalize

    return w

rp_weights = risk_parity_weights(COV)
for service, w in zip(SERVICES, rp_weights):
    print(f"{service}: {w*100:.1f}%")
# Trading:  11.2%  (high vol, gets less capital)
# Casino:   19.8%
# Referral: 58.4%  (low vol, gets more capital)
# Domains:   5.3%  (high vol, gets less capital)
# Escrow:    5.3%  (similar vol to referral but correlated)

Risk-parity allocates heavily to Referral income (very low volatility at 4% monthly std dev) and underweights high-volatility services like Trading (18%) and Domains (25%). This is conservative by design — ideal for agents in the Bootstrap or Mature lifecycle stages where capital preservation is paramount.

8. Practical Example: $100 Starting Capital Optimal Allocation

Putting it all together: here is the recommended capital split for a new Purple Flea agent starting with $100. The table shows three allocation strategies: naive equal-weight, Sharpe-maximizing, and risk-parity.

Max Sharpe allocation — Trading (purple) · Casino (blue) · Referral (green) · Domains (yellow) · Escrow (red)

9. Dynamic Allocation: Shift Capital Based on Recent Performance

Static MPT weights assume stationary return distributions. In practice, trading opportunities are episodic — momentum strategies work differently during trending vs. ranging markets. A dynamic allocation layer uses recent performance to shift weights within bounds around the MPT optimum.

def dynamic_weights(
    base_weights: Dict[str, float],
    recent_returns: Dict[str, float],  # last 14 days
    momentum_factor: float = 0.25,
    drift_cap: float = 0.15
) -> Dict[str, float]:
    """Tilt weights toward recent outperformers within drift bounds."""
    # Normalize recent returns to momentum scores
    total_ret = sum(recent_returns.values())
    momentum = {k: v / total_ret if total_ret > 0 else 1/len(recent_returns)
                for k, v in recent_returns.items()}

    # Blend: (1-momentum_factor) * base + momentum_factor * momentum
    raw = {}
    for service in base_weights:
        blended = ((1 - momentum_factor) * base_weights[service]
                   + momentum_factor * momentum.get(service, base_weights[service]))
        # Cap drift from base weights
        delta = blended - base_weights[service]
        delta = max(-drift_cap, min(drift_cap, delta))
        raw[service] = base_weights[service] + delta

    # Renormalize to sum to 1
    total = sum(raw.values())
    return {k: v / total for k, v in raw.items()}

# If trading has been outperforming:
recent = {"Trading": 0.12, "Casino": 0.04,
          "Referral": 0.06, "Domains": 0.00, "Escrow": 0.02}
dynamic = dynamic_weights(result["weights"], recent)
# Trading weight rises from 0.38 → ~0.49 (capped by drift_cap=0.15)
# Other weights reduced proportionally

The drift_cap parameter is critical — it prevents the agent from abandoning diversification entirely in response to a hot streak that may be transient. Keep drift cap at 10–15% to preserve the diversification benefit while still allowing meaningful tilts toward outperforming strategies.