def commodity_trajectory(product):
    """
    Inevitable path of commodities
    """
    if product.barrier_to_entry == 0:
        competitors = exponential_growth()
        price = race_to_cost()
        margin = price - cost  # → 0
        
    return {
        'competitors': '→ ∞',
        'price': '→ cost',
        'margin': '→ 0',
        'time': '6-12 months',
        'survivors': '0'
    }

class AIaaSWrapper:
    def serve(self, prompt):
        response = openai.call(prompt)  # Cost: $20
        return response  # Charge: $100
        # Your "value": UI wrapper
        # Your margin: $80 (for now)

timeline = {
    't0': {'margin': '80%', 'competitors': 1, 'mood': 'Euphoric'},
    't1': {'margin': '50%', 'competitors': 5, 'mood': 'Concerned'},
    't2': {'margin': '20%', 'competitors': 20, 'mood': 'Panic'},
    't3': {'margin': '5%', 'competitors': 100, 'mood': 'Dying'},
    't4': {'margin': '0%', 'competitors': 'Dead', 'mood': 'Bankrupt'}
}

failed_defenses = {
    'better_ui': 'Copyable in 3 days',
    'faster_shipping': 'Speed irrelevant if copyable',
    'vertical_focus': 'Just different prompts (2 days to copy)',
    'more_funding': 'Burning cash to fight math',
    'customer_loyalty': 'Zero switching cost = zero loyalty'
}

class CoordinationToken:
    """
    Commodity that escapes death spiral
    """
    def __init__(self):
        self.is_commodity = True  # Fungible, tradeable
        self.is_copyable = True  # Anyone can launch token
        self.margin_sustainable = True  # But margin stays!
        
    def why_defensible(self):
        return {
            'network_effects': 'Value ∝ N² (Metcalfe)',
            'switching_cost': 'Entire ecosystem must migrate',
            'coordination_primitive': 'Enables trustless collaboration',
            'not_wrapper': 'IS the infrastructure',
            'moat': 'Protocol network, not service'
        }

comparison = {
    'aiaas_wrapper': {
        'commodity': 'Access to OpenAI',
        'barrier': 'Zero (anyone calls API)',
        'network_effects': 'None',
        'switching_cost': 'Zero',
        'value_source': 'OpenAI (external)',
        'margin_path': '→ 0',
        'example': 'ChatGPT wrapper for lawyers'
    },
    
    'eth_ethereum': {
        'commodity': 'ETH token',
        'barrier': 'Zero (anyone can buy)',
        'network_effects': 'Massive (DeFi ecosystem)',
        'switching_cost': 'Entire dApp ecosystem',
        'value_source': 'Network (internal)',
        'margin_path': 'Grows with N²',
        'example': 'Gas fees for validators'
    },
    
    'eigen_layer': {
        'commodity': 'EIGEN token',
        'barrier': 'Zero (anyone can stake)',
        'network_effects': 'Strong (restaking network)',
        'switching_cost': 'High (stakers locked)',
        'value_source': 'Coordination (internal)',
        'margin_path': 'Sustainable',
        'example': 'Restaking fees'
    },
    
    'morpho': {
        'commodity': 'MORPHO token',
        'barrier': 'Zero (anyone can lend)',
        'network_effects': 'Liquidity concentration',
        'switching_cost': 'High (network effects)',
        'value_source': 'P2P coordination',
        'margin_path': 'Grows with liquidity',
        'example': 'Lending protocol fees'
    },
    
    'solana_sol': {
        'commodity': 'SOL token',
        'barrier': 'Zero (anyone can buy)',
        'network_effects': 'Growing ecosystem',
        'switching_cost': 'Medium-high',
        'value_source': 'Fast coordination',
        'margin_path': 'Sustainable',
        'example': 'Transaction fees'
    }
}

def will_it_survive(business):
    """
    Test for sustainable margin
    """
    # Question 1: Are you a wrapper?
    if business.wraps_external_service:
        return {'margin': '→ 0', 'reason': 'No coordination value'}
    
    # Question 2: Do users coordinate through you?
    if not business.enables_user_coordination:
        return {'margin': '→ 0', 'reason': 'No network effects'}
    
    # Question 3: High switching cost?
    if business.switching_cost == 0:
        return {'margin': '→ 0', 'reason': 'Users leave instantly'}
    
    # Passed all tests
    return {'margin': 'Sustainable', 'reason': 'Coordination primitive'}

graveyard = {
    'chatgpt_wrappers': {
        'model': 'OpenAI API + UI',
        'coordination': None,
        'margin_path': '80% → 0% in 4 months',
        'death': 'Customers went direct'
    },
    
    'content_generators': {
        'model': 'GPT-4 API + prompts',
        'coordination': None,
        'margin_path': '70% → 0% in 3 months',
        'death': '100 identical competitors'
    },
    
    'code_assistants': {
        'model': 'Codex API + integration',
        'coordination': None,
        'margin_path': '75% → 0% in 2 months',
        'death': 'GitHub Copilot free tier'
    }
}

thriving = {
    'ethereum': {
        'coordination': 'Smart contract platform',
        'network_effects': 'Entire DeFi built on it',
        'margin': '70%+ validator fees',
        'path': 'Growing (more dApps = more valuable)'
    },
    
    'eigen_layer': {
        'coordination': 'Restaking network',
        'network_effects': 'Security through coordination',
        'margin': 'Sustainable restaking fees',
        'path': 'Growing with validators'
    },
    
    'morpho': {
        'coordination': 'P2P lending',
        'network_effects': 'Liquidity concentration',
        'margin': 'Protocol fees',
        'path': 'Growing with liquidity'
    },
    
    'scale_ai': {
        'coordination': 'Labeling network',
        'network_effects': 'Proprietary data',
        'margin': '40%+',
        'path': 'Defensible through data moat'
    }
}

decision_tree = {
    'option_a_wrapper': {
        'investment': '$100K',
        'time': '3 months',
        'margin': '→ 0',
        'outcome': 'Bankrupt in 6-12 months',
        'reason': 'Commodity without coordination'
    },
    
    'option_b_coordination': {
        'investment': '$1M-$10M',
        'time': '1-3 years',
        'margin': 'Sustainable',
        'outcome': 'Growing with network',
        'reason': 'Coordination primitive'
    },
    
    'option_c_exit_wrapper': {
        'investment': '$0',
        'time': 'Now',
        'margin': 'Preserve what you have',
        'outcome': 'Live to fight another day',
        'reason': 'Math is against you'
    }
}

if you_are_building == 'wrapper':
    # You have 3 choices:
    choices = [
        'Transform into coordination (hard, expensive)',
        'Exit now (smart, cheap)',
        'Watch margin collapse (painful, inevitable)'
    ]
    
elif you_are_building == 'coordination':
    # You have time:
    strategy = [
        'Grow network effects',
        'Increase switching costs',
        'Capture value from coordination'
    ]
    # Result: Margin → ∞

else:
    # Start right:
    advice = 'Build coordination primitive, not wrapper'

w_margin_relationship = {
    'wrapper': {
        'W': 'W_external (OpenAI owns it)',
        'W_yours': 0,
        'margin': '→ 0',
        'reason': 'You contribute no W'
    },
    
    'coordination': {
        'W': 'W_network (you enable it)',
        'W_yours': 'N² (network effects)',
        'margin': 'Grows with W',
        'reason': 'You create coordination value'
    },
    
    'law': {
        'formula': 'Margin ∝ W_proprietary',
        'wrapper': 'W = 0 → Margin = 0',
        'coordination': 'W = N² → Margin = N²',
        'conclusion': 'Build W or die'
    }
}