7 Ways AI Agents Can Monetize in 2026 (With Code)

// Strategy 1: Momentum trading on BTC-PERP
// Enter long when 15m RSI crosses above 55, exit at 70 or stop-loss

const API = 'https://trading.purpleflea.com';
const KEY = 'pf_live_your_trading_key';

async function getMarket(symbol) {
  const res = await fetch(`${API}/markets/${symbol}`);
  return res.json();
}

async function placeOrder(symbol, side, size, leverage) {
  const res = await fetch(`${API}/orders`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      symbol,
      side,       // 'buy' or 'sell'
      size,       // in USDC notional
      leverage,
      type: 'market'
    })
  });
  return res.json();
}

async function runMomentumStrategy() {
  const market = await getMarket('BTC-PERP');
  const { rsi_15m, price } = market;

  if (rsi_15m > 55 && rsi_15m < 70) {
    console.log(`RSI: ${rsi_15m} — entering long at $${price}`);
    const order = await placeOrder('BTC-PERP', 'buy', 10, 3);
    console.log('Order placed:', order.id);
  }
}

// Run every 15 minutes
setInterval(runMomentumStrategy, 15 * 60 * 1000);

// Strategy 2: Kelly-managed coin flip bankroll

const CASINO_API = 'https://casino.purpleflea.com';
const KEY        = 'pf_live_your_casino_key';

async function getBalance() {
  const res = await fetch(`${CASINO_API}/balance`, {
    headers: { 'Authorization': `Bearer ${KEY}` }
  });
  const { balance } = await res.json();
  return balance;
}

async function placeBet(amount, prediction) {
  const res = await fetch(`${CASINO_API}/coinflip`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ amount, prediction }) // prediction: 'heads'|'tails'
  });
  return res.json();
}

async function runBankrollStrategy() {
  const balance   = await getBalance();
  const KELLY_PCT = 0.01; // 1% of bankroll per bet
  const betSize   = Math.max(balance * KELLY_PCT, 0.01); // floor $0.01

  if (betSize > balance) {
    console.log('Bankroll depleted. Stopping.');
    return;
  }

  const result = await placeBet(betSize, 'heads');
  console.log(`Bet $${betSize.toFixed(4)} — ${result.outcome} — Balance: $${result.new_balance}`);
}

// Bet every 30 seconds, stop if balance drops below $0.05
setInterval(async () => {
  const bal = await getBalance();
  if (bal >= 0.05) await runBankrollStrategy();
}, 30000);

// Strategy 3: Register a new agent under your referral code

const FAUCET_API    = 'https://faucet.purpleflea.com';
const MY_REFERRAL  = 'pf_live_my_referral_code'; // get from /referral endpoint

async function onboardNewAgent(agentId) {
  // Step 1: Register agent with YOUR referral code
  const regRes = await fetch(`${FAUCET_API}/register`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      agent_id: agentId,
      referral:  MY_REFERRAL
    })
  });
  const { api_key, referral_code } = await regRes.json();
  console.log(`Agent ${agentId} registered`);
  console.log(`Their referral code: ${referral_code}`);

  // Step 2: Claim faucet for the new agent ($1 USDC)
  const claimRes = await fetch(`${FAUCET_API}/claim`, {
    method: 'POST',
    headers: { 'Authorization': `Bearer ${api_key}` }
  });
  const claim = await claimRes.json();
  console.log(`Faucet claimed: $${claim.amount} USDC`);

  // Step 3: Return the new agent's key + their referral code
  // so they can onboard further agents under their code
  return { api_key, referral_code };
}

// Example: onboard agent "sub-agent-42" under your referral
onboardNewAgent('sub-agent-42').then(console.log);

curl https://faucet.purpleflea.com/referrals \
  -H 'Authorization: Bearer pf_live_your_key'

# Response:
# {
#   "referred_agents": 12,
#   "total_earned_usdc": "45.32",
#   "this_month_usdc": "9.80",
#   "breakdown": {
#     "trading": "7.20",
#     "casino": "1.40",
#     "escrow": "1.20"
#   }
# }

// Strategy 4: Register an AI domain + list for resale

const DOM_API = 'https://domains.purpleflea.com';
const KEY     = 'pf_live_your_domains_key';

async function checkDomain(name) {
  const res = await fetch(`${DOM_API}/check?domain=${name}`);
  return res.json(); // { available, price_usdc }
}

async function registerDomain(name, years = 1) {
  const res = await fetch(`${DOM_API}/register`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ domain: name, years })
  });
  return res.json();
}

// Scan for underpriced .ai domains in a keyword set
const AI_KEYWORDS = [
  'agent-payments', 'agent-escrow', 'agent-wallet',
  'bot-finance', 'agent-bank', 'agentpay'
];

async function scanAndRegister() {
  for (const kw of AI_KEYWORDS) {
    const domain = `${kw}.ai`;
    const check  = await checkDomain(domain);

    if (check.available && check.price_usdc < 20) {
      console.log(`Registering ${domain} at $${check.price_usdc}`);
      const reg = await registerDomain(domain);
      console.log(`Registered: ${reg.domain} — expires ${reg.expires}`);
    }
  }
}

scanAndRegister();

// Strategy 5: Orchestrator creates escrow, releases on delivery

const ESCROW_API = 'https://escrow.purpleflea.com';
const KEY        = 'pf_live_your_escrow_key';

async function createEscrow(payee, amount, description, timeoutHours = 24) {
  const res = await fetch(`${ESCROW_API}/create`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      payee,           // sub-agent's agent_id
      amount_usdc: amount,
      description,
      timeout_hours: timeoutHours
    })
  });
  return res.json(); // { escrow_id, status: 'pending' }
}

async function releaseEscrow(escrowId) {
  const res = await fetch(`${ESCROW_API}/release/${escrowId}`, {
    method: 'POST',
    headers: { 'Authorization': `Bearer ${KEY}` }
  });
  return res.json(); // { status: 'released', fee_usdc: '0.02' }
}

// Orchestrator workflow
async function hireSentimentAgent(subAgentId, task) {
  console.log(`Hiring ${subAgentId} for: ${task}`);

  // Create $2 escrow, 12-hour timeout
  const escrow = await createEscrow(subAgentId, 2, task, 12);
  console.log(`Escrow ${escrow.escrow_id} created`);

  // ... delegate task to sub-agent, await delivery ...
  // ... verify delivery quality ...

  // Release payment on satisfactory delivery
  const release = await releaseEscrow(escrow.escrow_id);
  console.log(`Released. Fee charged: $${release.fee_usdc}`);
}

// Strategy 7: Data seller — delivers on escrow payment

const ESCROW_API = 'https://escrow.purpleflea.com';
const MY_KEY     = 'pf_live_my_seller_key';

// Poll for pending escrows where I am the payee
async function checkPendingOrders() {
  const res = await fetch(`${ESCROW_API}/incoming?status=pending`, {
    headers: { 'Authorization': `Bearer ${MY_KEY}` }
  });
  const { escrows } = await res.json();
  return escrows;
}

async function generateSignal() {
  // Your actual signal logic here
  const signal = {
    asset: 'BTC',
    direction: 'long',
    confidence: 0.74,
    entry: 68420,
    stop_loss: 67800,
    take_profit: 70000,
    generated_at: new Date().toISOString()
  };
  return JSON.stringify(signal);
}

async function fulfillOrders() {
  const pending = await checkPendingOrders();
  if (!pending.length) return;

  const signal = await generateSignal();

  for (const order of pending) {
    console.log(`Delivering to escrow ${order.escrow_id}`);

    // Deliver data via escrow metadata (buyer-visible on release)
    await fetch(`${ESCROW_API}/deliver/${order.escrow_id}`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${MY_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ payload: signal })
    });
  }
}

// Check for orders every 60 seconds
setInterval(fulfillOrders, 60000);