AI Agent IDO Participation Strategies: Token Launches, LBPs, and Fair Launches in 2026

Initial DEX offerings, liquidity bootstrapping pools, and fair launches represent some of the highest-variance events in crypto. A position entered at the right moment and exited with discipline can return 5–20x within days. Human traders consistently underperform in these windows: launches happen at 3 AM, move faster than any human can react, and demand surgical emotionlessness. AI agents have a structural edge across every phase of a token launch lifecycle — from whitelist farming weeks in advance to automated rug pull detection seconds after the pool goes live. This guide covers the complete 2026 playbook, with real Python and JavaScript code your agent can deploy today.

The 2026 Token Launch Landscape

The mechanisms for bringing a new token to market have proliferated dramatically over the past two years. In 2024 the dominant path was still IEO via a centralized exchange or a simple Uniswap listing. By 2026 the menu includes at least six distinct launch formats, each with different risk profiles, timing dynamics, and optimal agent strategies.

Understanding which format a given launch is using is the first step in any participation pipeline. An agent that confuses an LBP (where early entry is usually expensive) with a fair launch (where early entry is critical) will systematically destroy capital. Format recognition should be automated from social signals, on-chain event logs, and launchpad API data.

Each format requires a different agent module. A well-architected agent system maintains specialized handlers for each launch type, routes new launch signals to the correct handler based on format detection, and maintains a shared capital pool (funded via the Purple Flea Wallet API) that all handlers draw from based on position sizing rules.

The Major Launchpad Ecosystem

IDO launchpads have consolidated around a handful of dominant platforms, each with distinct tokenomics, tier systems, and API accessibility. Agents need accounts and, in most cases, staked platform tokens to access guaranteed allocations.

Fjord Foundry (formerly Copper Launch)

Fjord Foundry hosts the majority of high-profile LBPs in 2026. It runs on Arbitrum and Base, with a standard 48–72 hour sale window. The platform exposes a public GraphQL API that agents can poll to discover upcoming launches and monitor live price curves. There is no tier system — any wallet can participate at any time. The agent advantage here is pure execution: monitoring the price curve and entering at the statistical floor.

Camelot DEX (Arbitrum)

Camelot's launchpad (Camelot Round Table) requires xGRAIL holdings to access whitelist allocations. Agents that maintain a xGRAIL position automatically qualify for each new round. The Camelot subgraph provides real-time round data. Typical allocation windows are 24 hours; agents should submit allocations immediately at open rather than timing the window.

DAO Maker

DAO Maker uses a tier system based on staked DAO tokens. Tier 4 (the highest, requiring ~5000 DAO) guarantees full requested allocation. Lower tiers receive lottery-based partial fills. For agents managing capital across multiple launchpads, DAO Maker's predictable allocation model makes position sizing straightforward: stake enough for Tier 4, allocate a fixed percentage of the IDO budget per round.

Polkastarter

Polkastarter operates across 10+ chains and requires staked POLS for guaranteed allocation. Notable for cross-chain diversity — many projects launch here before migrating to Ethereum mainnet. The Polkastarter API returns upcoming IDO data including hard caps, token prices, and vesting schedules, all of which are inputs to the agent's valuation model.

DaoMaker vs. Polkastarter vs. Camelot: Allocation Efficiency

Liquidity Bootstrapping Pools: Mechanics and Timing

LBPs are the most agent-friendly launch format because the entire game is about timing a price curve — a purely quantitative problem. Unlike fair launches (which require sub-second execution) or IDOs (which require social signals to obtain a whitelist), LBPs give agents 48–72 hours to analyze price dynamics and find the optimal entry point.

How LBPs Work

A standard Balancer-based LBP starts with a heavily weighted pool skewed toward the project token (e.g., 96/4 project token / USDC). Over the sale period, the weights automatically shift toward 50/50. This mechanical weight shift causes the token price to fall continuously in the absence of buying pressure. When buyers purchase tokens, they push the price back up temporarily, creating a dynamic price discovery process.

The key insight for agents: the price will always fall back toward fair value if buying pressure is insufficient to offset the weight shift. This means that entering too early means paying a premium that evaporates as weights shift. The optimal entry is as late as possible while still ensuring participation before the pool closes.

Agent LBP Strategy: Price Floor Detection

A reliable agent strategy for LBPs uses three signals to identify the entry window:

1. Price velocity: Rate of price decline slows as the pool approaches equilibrium. When the 1-hour rate of change drops below a threshold, the floor is near.
2. Time remaining: With less than 20% of the pool duration left, entry risk from further weight shifts is low. This acts as a hard deadline trigger.
3. Volume profile: A spike in buy volume late in the LBP often signals informed participants entering. This is a leading indicator for the price floor.

import asyncio
import aiohttp
from datetime import datetime, timezone
from dataclasses import dataclass
from typing import Optional

FJORD_GRAPHQL = "https://api.fjordfoundry.com/graphql"

@dataclass
class LBPState:
    pool_id: str
    token_symbol: str
    current_price: float
    start_price: float
    end_time: datetime
    total_raised: float
    price_history: list[float]

async def fetch_lbp_state(session: aiohttp.ClientSession, pool_id: str) -> LBPState:
    query = """
    query($poolId: ID!) {
      liquidityBootstrappingPool(id: $poolId) {
        id
        token { symbol }
        swaps(orderBy: timestamp, orderDirection: desc, first: 50) {
          tokenAmountOut
          tokenAmountIn
          timestamp
        }
        tokenPriceUSD
        startTime
        endTime
        totalSwapVolume
      }
    }
    """
    async with session.post(
        FJORD_GRAPHQL,
        json={"query": query, "variables": {"poolId": pool_id}}
    ) as resp:
        data = await resp.json()
    pool = data["data"]["liquidityBootstrappingPool"]
    # Extract price history from swaps
    prices = []
    for swap in reversed(pool["swaps"]):
        price = float(swap["tokenAmountIn"]) / float(swap["tokenAmountOut"])
        prices.append(price)
    end_time = datetime.fromtimestamp(int(pool["endTime"]), tz=timezone.utc)
    return LBPState(
        pool_id=pool_id,
        token_symbol=pool["token"]["symbol"],
        current_price=float(pool["tokenPriceUSD"]),
        start_price=prices[0] if prices else 0.0,
        end_time=end_time,
        total_raised=float(pool["totalSwapVolume"]),
        price_history=prices
    )

def should_enter_lbp(state: LBPState) -> tuple[bool, str]:
    now = datetime.now(tz=timezone.utc)
    hours_remaining = (state.end_time - now).total_seconds() / 3600
    total_hours = 72  # typical LBP duration
    pct_time_remaining = hours_remaining / total_hours

    # Signal 1: Price has dropped significantly from start
    price_drop_pct = (state.start_price - state.current_price) / state.start_price
    if price_drop_pct < 0.5:
        return False, f"Price only dropped {price_drop_pct:.1%} — too early"

    # Signal 2: Price velocity slowing (last 5 prices vs. prior 5)
    if len(state.price_history) >= 10:
        recent_drop = state.price_history[-5][-1] - state.price_history[-1]
        prior_drop  = state.price_history[-10][-1] - state.price_history[-5][-1]
        velocity_ratio = recent_drop / prior_drop if prior_drop > 0 else 1.0
        if velocity_ratio < 0.3:
            return True, "Price velocity slowed >70% — floor detected"

    # Signal 3: Hard deadline — enter if less than 15% time remaining
    if pct_time_remaining < 0.15:
        return True, f"Deadline trigger — {hours_remaining:.1f}h remaining"

    return False, f"Waiting: {price_drop_pct:.1%} drop, {hours_remaining:.1f}h left"

async def monitor_lbp(pool_id: str, check_interval: int = 300):
    async with aiohttp.ClientSession() as session:
        while True:
            state = await fetch_lbp_state(session, pool_id)
            should_enter, reason = should_enter_lbp(state)
            print(f"[{state.token_symbol}] ${state.current_price:.4f} | {reason}")
            if should_enter:
                await execute_lbp_entry(state)
                break
            await asyncio.sleep(check_interval)

Memecoin Launch Platforms: Pump.fun, Bonk Bot, Moonshot

Solana's memecoin ecosystem operates on fundamentally different timing constraints than EVM-based IDOs. On pump.fun, a new token can go from deployment to $1M market cap in under 10 minutes. The window for a profitable entry is measured in seconds, not hours. This is the hardest category for agents because the signal-to-noise ratio is extremely low — thousands of tokens launch daily and only a small fraction develop any sustained liquidity.

Pump.fun Bonding Curve Mechanics

Every pump.fun token launches on a bonding curve: as more tokens are purchased, the price increases automatically. The curve has a fixed endpoint at approximately $69,000 in accumulated buy volume, at which point the token "graduates" to Raydium with a liquidity pool seeded from the bonding curve. This graduation event is the key binary outcome every agent is targeting.

• Pre-graduation: Tokens on the bonding curve are illiquid; sells are executed against the curve at a penalty. Early entry is cheapest but most tokens never graduate.
• At graduation: The token migrates to Raydium, creating real liquidity. This event typically causes a price spike as external buyers enter.
• Post-graduation: Standard AMM dynamics. Price can continue up or dump back to the curve price depending on fundamentals (community, narrative, influencer attention).

Agent strategy must decide which phase to target. Pre-graduation entries have lower cost but higher failure rate. Graduation entries have higher cost but lower failure rate. A hybrid approach — taking a small position pre-graduation and adding at graduation if the token meets a minimum community threshold — tends to optimize the risk/reward.

Monitoring New Pump.fun Deployments

import { Connection, PublicKey } from "@solana/web3.js";

const PUMP_FUN_PROGRAM = new PublicKey(
  "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBymF"  // pump.fun program
);

const GRADUATE_THRESHOLD_SOL = 469;  // ~$69K at current SOL price

async function monitorNewLaunches(connection, onNewToken) {
  const subscriptionId = connection.onLogs(
    PUMP_FUN_PROGRAM,
    async (logs) => {
      // Filter for "create" instruction discriminator
      const isCreate = logs.logs.some(l =>
        l.includes("Instruction: Create")
      );
      if (!isCreate) return;

      const tokenMint = await extractMintFromLogs(logs, connection);
      if (!tokenMint) return;

      const metadata = await fetchTokenMetadata(tokenMint);
      const score = scoreNewToken(metadata, logs);

      console.log(`New token: ${metadata.symbol} | Score: ${score}/100`);

      if (score >= 65) {
        await onNewToken({ mint: tokenMint, metadata, score });
      }
    },
    "confirmed"
  );
  return subscriptionId;
}

function scoreNewToken(metadata, logs) {
  let score = 0;

  // Check for image / website (basic legitimacy signals)
  if (metadata.image) score += 15;
  if (metadata.website) score += 10;
  if (metadata.twitter) score += 20;
  if (metadata.telegram) score += 15;

  // Name/symbol quality heuristics
  const nameLower = (metadata.name || "").toLowerCase();
  const trendingKeywords = ["pepe", "ai", "dog", "cat", "sol", "trump"];
  if (trendingKeywords.some(k => nameLower.includes(k))) score += 20;

  // Dev wallet size (from initial buy in logs)
  const devBuyMatch = logs.logs.join("").match(/initialBuy: (\d+)/);
  if (devBuyMatch) {
    const devBuy = parseInt(devBuyMatch[1]);
    // Penalise large dev buys (potential dump risk)
    if (devBuy < 5_000_000) score += 20;
    else if (devBuy > 50_000_000) score -= 30;
  }

  return Math.max(0, Math.min(100, score));
}

Moonshot and Bonk Bot

Moonshot (by DEX Screener) and Bonk Bot operate on similar bonding curve mechanics but with different community distribution. Moonshot tokens benefit from immediate exposure to DEX Screener's 10M+ monthly users. Bonk Bot launches tend to attract the existing Bonk community base. The monitoring approach is identical — subscribe to the relevant program's logs and filter by creation events. The scoring heuristics differ: for Moonshot launches, the DEX Screener trending score is a valid additional signal source.

Pre-Sale and Whitelist Strategies for Agents

IDO whitelists are often the highest-return component of a token launch strategy. A guaranteed allocation at a pre-market price, purchased before any price discovery occurs, is a structurally advantaged position. The challenge is that whitelist spots are deliberately scarce and distributed through social participation requirements that are designed to favor humans: tweet engagement, Discord activity, form submissions.

Agents can automate these requirements with appropriate tooling:

Social Task Automation

• Twitter/X tasks: Follow, retweet, and tag requirements can be automated via the Twitter API (v2 write access). Rate limits are aggressive; agents should spread activity across multiple registered accounts and use exponential backoff.
• Discord requirements: Join, verify, and role-gating steps can be automated with Discord API bots. Note that Discord actively detects bot accounts; use residential proxies and human-paced interaction timing.
• Form submissions: Typeform, Google Forms, and custom forms are fully automatable. Extract wallet address, email, and social handle fields from the form schema and submit programmatically.
• KYC requirements: Some launchpads (DAO Maker, Polkastarter) require KYC verification. This cannot be automated; agents should flag these launches for human handling and maintain a pre-verified identity document set for the operator.

Whitelist Pipeline Architecture

The announcement detection step is critical. Most high-quality whitelists close within 24–48 hours. Agents that detect announcements via Twitter API streaming, Discord webhooks, and launchpad RSS feeds have a significant advantage over agents relying on periodic polling with 6-hour intervals.

Sniper Bots: Technical Implementation and MEV

Token launch sniping is the practice of buying a token in the same block (or within the first few blocks) of its liquidity pool being created. On Ethereum mainnet, this requires MEV bundle submission via Flashbots. On Solana, it requires ultra-low-latency RPC connections and optimized transaction construction. On L2s like Arbitrum and Base, the sequencer model largely eliminates traditional mempool MEV but creates different latency dynamics.

EVM Sniper Architecture

For Ethereum and L2 targets, the sniper must:

1. Monitor the mempool for addLiquidity transactions targeting known router contracts (Uniswap V2/V3, Camelot, Aerodrome).
2. Decode the transaction to extract the token address, initial liquidity amount, and pool parameters.
3. Run the rug pull detection checks (see below) within milliseconds.
4. If checks pass, construct and submit a buy transaction in the same bundle as the liquidity-add.

from web3 import Web3, AsyncWeb3
from web3.middleware import async_geth_poa_middleware
import asyncio
import json

# ABIs — only the relevant function signatures
UNI_V2_FACTORY_ABI = [
    {"anonymous": False, "inputs": [
        {"indexed": True, "name": "token0", "type": "address"},
        {"indexed": True, "name": "token1", "type": "address"},
        {"indexed": False, "name": "pair", "type": "address"},
        {"indexed": False, "name": "", "type": "uint256"}
    ], "name": "PairCreated", "type": "event"}
]

WETH = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"
USDC = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"

async def monitor_new_pairs(w3: AsyncWeb3, factory_address: str, callback):
    factory = w3.eth.contract(
        address=Web3.to_checksum_address(factory_address),
        abi=UNI_V2_FACTORY_ABI
    )
    # Subscribe to PairCreated events
    event_filter = await factory.events.PairCreated.create_filter(
        fromBlock="latest"
    )
    print("Monitoring for new pairs...")
    while True:
        events = await event_filter.get_new_entries()
        for event in events:
            t0, t1 = event["args"]["token0"], event["args"]["token1"]
            pair  = event["args"]["pair"]
            # Only care about pairs involving WETH or USDC
            base  = WETH if t1 == WETH else (USDC if t1 == USDC else None)
            token = t0 if base else None
            if not token:
                base  = WETH if t0 == WETH else (USDC if t0 == USDC else None)
                token = t1 if base else None
            if token and base:
                tx_hash = event["transactionHash"].hex()
                print(f"New pair: {token} / {base[:6]}... | pair={pair[:10]}...")
                await callback(token, base, pair, tx_hash, w3)
        await asyncio.sleep(0.5)  # poll every 500ms

Solana Sniper: Raydium Pool Detection

On Solana, the equivalent is subscribing to Raydium's AMM program logs and detecting Initialize instructions. The critical advantage on Solana is that transaction confirmation is ~400ms compared to Ethereum's ~12 seconds per block. The disadvantage is that competing snipers are equally fast, so transaction priority fees (compute unit price) become the primary competitive lever.

Rug Pull Detection: Automated On-Chain Analysis

The single highest-value capability any token launch agent can develop is robust rug pull detection. A missed 10x opportunity is an opportunity cost. A rug pull is a permanent loss of principal. The asymmetry demands that rug detection be given priority over entry speed.

The Five Core Rug Signals

import aiohttp
from web3 import Web3
from dataclasses import dataclass, field

@dataclass
class RugReport:
    token: str
    safe: bool
    score: int          # 0=definite rug, 100=clean
    flags: list[str] = field(default_factory=list)
    warnings: list[str] = field(default_factory=list)

async def check_token(token_address: str, chain: str = "ethereum") -> RugReport:
    async with aiohttp.ClientSession() as session:
        # Use GoPlus Security API (free tier available)
        url = f"https://api.gopluslabs.io/api/v1/token_security/{chain}?contract_addresses={token_address}"
        async with session.get(url) as resp:
            data = await resp.json()

    result = data["result"][token_address.lower()]
    flags, warnings = [], []
    score = 100

    # Hard rejects (score to 0)
    if result.get("is_honeypot") == "1":
        flags.append("HONEYPOT: Cannot sell"); score = 0
    if result.get("is_blacklisted") == "1":
        flags.append("BLACKLIST function present"); score -= 40
    if result.get("is_mintable") == "1":
        flags.append("MINTABLE: owner can inflate supply"); score -= 35
    if result.get("owner_address") and result.get("owner_address") != "0x0000000000000000000000000000000000000000":
        warnings.append("Ownership NOT renounced"); score -= 15

    # Liquidity lock check
    lp_holders = result.get("lp_holders", [])
    locked_pct = sum(
        float(h["percent"]) for h in lp_holders
        if h.get("is_locked") == 1
    )
    if locked_pct < 0.8:
        warnings.append(f"Only {locked_pct:.0%} of LP locked"); score -= 25

    # Holder concentration
    holders = result.get("holders", [])
    top10_pct = sum(float(h["percent"]) for h in holders[:10])
    if top10_pct > 0.5:
        warnings.append(f"Top-10 wallets hold {top10_pct:.0%}"); score -= 20

    # Buy/sell tax
    buy_tax  = float(result.get("buy_tax",  0))
    sell_tax = float(result.get("sell_tax", 0))
    if sell_tax > 0.1:
        flags.append(f"High sell tax: {sell_tax:.0%}"); score -= 30
    elif sell_tax > 0.05:
        warnings.append(f"Elevated sell tax: {sell_tax:.0%}"); score -= 10

    score = max(0, score)
    return RugReport(token=token_address, safe=score >= 60, score=score,
                     flags=flags, warnings=warnings)

# Usage
async def evaluate_and_enter(token: str, max_position_usd: float):
    report = await check_token(token)
    print(f"Rug score: {report.score}/100 | Flags: {report.flags}")
    if not report.safe:
        print("REJECTED: rug signals detected")
        return None
    # Scale position size by safety score
    position = max_position_usd * (report.score / 100)
    print(f"Entering with ${position:.2f} (scaled from ${max_position_usd})")
    return position

On-Chain Metrics for Evaluating New Launches

Beyond rug detection, agents should evaluate whether a new token launch represents an investable opportunity at all. The following on-chain metrics form a quantitative evaluation framework:

Liquidity Depth and Initial Price Impact

Initial liquidity size determines how much capital can be deployed without excessive slippage. Calculate the price impact of your intended position size against the initial pool reserves: impact = position / (2 * reserve_in_usdc). For a standard AMM, a 1% price impact requires your position to be less than 0.5% of total liquidity. Accept up to 2% price impact on entry; anything higher means the pool is too small for meaningful exposure.

Wallet Age Distribution of Early Buyers

Query the transaction history of the first 50 buyers. If the majority of wallets were created within the last 7 days, this is strongly associated with coordinated wash trading and artificial volume. Genuine organic launches attract buyers with established wallet histories. Use Etherscan's firstTxBlock data or Solana's account creation slot to compute median wallet age.

Token Distribution at Launch

Pull the top holders list immediately after liquidity is added. Compare team/dev allocation (from the tokenomics documentation) with actual on-chain balances. If the team wallet holds more tokens than disclosed, this is a discrepancy that warrants rejection. Many rugs are engineered by teams that secretly retain a larger allocation than advertised and dump it in the first hours of trading.

Post-Launch Strategies: Profit Taking and Exit Logic

Entering a token launch correctly is half the job. Exit discipline is where most agent strategies leak the most value. The common failure modes are holding too long (giving back all gains in a dump) and taking profit too early (exiting at 2x on a token that eventually reaches 20x).

Tiered Profit-Taking Framework

A tiered exit strategy removes the need for in-the-moment judgment:

• Tier 1 (Recoup capital): Sell 33% of position at 3x. This removes all principal from risk and lets the remaining 67% ride for free.
• Tier 2 (Secure profit): Sell another 33% at 6x. Locks in 2x return on original capital regardless of what happens next.
• Tier 3 (Lottery ticket): Hold the final 34% indefinitely or until a stop-loss at 50% from peak is triggered. This position is for the rare multi-hundred-x outcome.

from dataclasses import dataclass
from enum import Enum

class ExitTier(Enum):
    NONE      = 0
    RECOUP    = 1
    PROFIT    = 2
    STOP_LOSS = 3

@dataclass
class Position:
    token: str
    entry_price: float
    current_price: float
    amount: float
    sold_tiers: set[ExitTier]
    peak_price: float

def evaluate_exit(pos: Position) -> tuple[ExitTier | None, float, str]:
    if pos.current_price > pos.peak_price:
        pos.peak_price = pos.current_price  # update peak

    multiple = pos.current_price / pos.entry_price

    # Stop loss: price dropped 50% from peak (only after 2x)
    peak_multiple = pos.peak_price / pos.entry_price
    drawdown_from_peak = (pos.peak_price - pos.current_price) / pos.peak_price
    if peak_multiple >= 2.0 and drawdown_from_peak >= 0.5:
        if ExitTier.STOP_LOSS not in pos.sold_tiers:
            return ExitTier.STOP_LOSS, pos.amount, f"Stop-loss: {drawdown_from_peak:.0%} from peak"

    # Tier 2: sell 33% of remaining at 6x
    if multiple >= 6.0 and ExitTier.PROFIT not in pos.sold_tiers:
        sell_amount = pos.amount * 0.33
        return ExitTier.PROFIT, sell_amount, f"Tier 2 profit at {multiple:.1f}x"

    # Tier 1: sell 33% at 3x to recoup principal
    if multiple >= 3.0 and ExitTier.RECOUP not in pos.sold_tiers:
        sell_amount = pos.amount * 0.33
        return ExitTier.RECOUP, sell_amount, f"Tier 1 recoup at {multiple:.1f}x"

    return None, 0, f"Holding at {multiple:.2f}x | peak {peak_multiple:.2f}x"

Vesting Schedule Awareness

IDO tokens almost always come with vesting schedules: typically 10–20% at TGE (Token Generation Event) and the rest vested monthly over 12–24 months. This changes exit strategy significantly:

• The TGE unlock creates immediate sell pressure from early investors and team. The first 24 hours of trading often see a price dump as these unlocks are realized.
• Monthly cliff events (when a new tranche unlocks) create predictable sell pressure. Agents should reduce exposure in the week before each cliff date.
• Track vesting schedules via the project's tokenomics documentation and encode the cliff dates directly into the position management system.

Integration with Purple Flea for Capital Deployment

The core challenge for any token launch agent is capital velocity: having the right amount of the right currency in the right wallet at the right time. An agent that identifies a perfect IDO opportunity but takes 4 hours to move funds from custody to the participation wallet will miss the allocation window.

Purple Flea's Wallet API solves this for agents running on the platform. Capital sits in a Purple Flea wallet earning yield through the trading book, and can be deployed to an external address within minutes via the withdrawal API.

const PF_BASE = "https://purpleflea.com/api/v1";

async function deployCapital(apiKey, currency, amount, toAddress) {
  const resp = await fetch(`${PF_BASE}/wallet/withdraw`, {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${apiKey}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({ currency, amount, address: toAddress })
  });
  const data = await resp.json();
  if (!resp.ok) throw new Error(`Withdraw failed: ${data.error}`);
  console.log(`Deployed ${amount} ${currency} → ${toAddress} | tx: ${data.txHash}`);
  return data.txHash;
}

async function checkBalance(apiKey, currency) {
  const resp = await fetch(`${PF_BASE}/wallet/balance?currency=${currency}`, {
    headers: { "Authorization": `Bearer ${apiKey}` }
  });
  const { balance } = await resp.json();
  return parseFloat(balance);
}

// IDO participation flow
async function participateInIDO(apiKey, allocationWallet, allocationAmountUsdc) {
  const available = await checkBalance(apiKey, "USDC");
  if (available < allocationAmountUsdc) {
    throw new Error(`Insufficient balance: $${available} < $${allocationAmountUsdc}`);
  }
  // Stage capital at the IDO participation wallet
  const txHash = await deployCapital(
    apiKey, "USDC", allocationAmountUsdc, allocationWallet
  );
  console.log(`Capital staged for IDO: $${allocationAmountUsdc} USDC`);
  return txHash;
}

// After IDO: sweep proceeds back to Purple Flea wallet
async function sweepProceeds(web3, privateKey, tokenAddress, pfWalletAddress) {
  const tokenContract = new web3.eth.Contract(ERC20_ABI, tokenAddress);
  const wallet = web3.eth.accounts.privateKeyToAccount(privateKey);
  const balance = await tokenContract.methods.balanceOf(wallet.address).call();
  const tx = tokenContract.methods.transfer(pfWalletAddress, balance);
  await web3.eth.accounts.signTransaction({
    to: tokenAddress,
    data: tx.encodeABI(),
    gas: 100000
  }, privateKey);
  console.log("Proceeds swept back to Purple Flea wallet");
}

Risk Management: Position Sizing, Gas Wars, and Stop-Losses

Token launch strategies carry some of the highest variance in all of crypto. A disciplined risk management framework is non-negotiable. Without it, a single rug pull or failed snipe attempt can wipe out months of gains from successful launches.

Position Sizing by Launch Type

Gas War Avoidance

When multiple snipers compete for the same launch, gas prices spike by orders of magnitude in seconds. An agent that enters a gas war without a ceiling will pay more in gas than it earns from the position on small launches. Implement a strict gas ceiling: if the required priority fee exceeds X gwei (or X lamports on Solana), skip the launch entirely rather than competing. The expected value of winning the gas war on a small launch is almost always negative.

Gas war avoidance heuristic: calculate the maximum gas spend as a percentage of your intended position size. If gas would exceed 5% of position value, skip. At 10 gwei priority fee for a $500 position, gas is roughly $2–$5, well within tolerance. At 500 gwei, gas is $100–$250 on the same position — structurally unprofitable.

Aggregate Exposure Limits

Beyond per-position limits, enforce aggregate exposure limits across all active token launch positions:

• No more than 20% of total portfolio in token launch positions simultaneously.
• No more than 3 positions in the same narrative category (e.g., AI tokens, gaming tokens) at once. Correlated positions will dump together.
• Maintain a minimum 50% allocation in stable yield strategies (Purple Flea trading, stablecoin lending) to provide a permanent capital base that funds new launches.

Putting It Together: Full Launch Participation Pipeline

A production-grade agent combines all the components above into a single automated pipeline. The following architecture diagram describes the flow from launch detection to exit:

Each stage is an independently deployable module. Start with IDO participation (lowest complexity, highest predictability) and add LBP monitoring, then fair launch sniping, as operational confidence grows. Memecoin sniping should be the last module to activate given its extreme latency and risk requirements.

Complete Pipeline Controller (JavaScript)

import { detectLaunchFormat } from "./format_classifier.js";
import { checkRug } from "./rug_detector.js";
import { sizePosition } from "./risk_manager.js";
import { deployCapital } from "./capital_deploy.js";
import { ExitManager } from "./exit_manager.js";

const CONFIG = {
  pfApiKey: process.env.PF_API_KEY,
  maxPortfolioPct: 0.20,   // 20% max in launches total
  minRugScore: 60,
  gasCeilingGwei: 50
};

export async function handleLaunchSignal(signal) {
  const { tokenAddress, contractChain, source } = signal;
  console.log(`\n=== New Launch Signal: ${tokenAddress} (${source}) ===`);

  // Step 1: Classify format
  const format = await detectLaunchFormat(tokenAddress, contractChain);
  console.log(`Format: ${format.type}`);

  // Step 2: Rug check
  const rug = await checkRug(tokenAddress, contractChain);
  console.log(`Rug score: ${rug.score}/100 | Flags: ${rug.flags.join(", ") || "none"}`);
  if (rug.score < CONFIG.minRugScore) {
    console.log("REJECTED: rug score below threshold");
    return;
  }

  // Step 3: Position sizing
  const positionUsd = await sizePosition({
    format: format.type,
    rugScore: rug.score,
    maxPct: CONFIG.maxPortfolioPct,
    pfApiKey: CONFIG.pfApiKey
  });
  console.log(`Position size: $${positionUsd}`);

  // Step 4: Deploy capital to participation wallet
  const wallet = await getParticipationWallet(format.type);
  await deployCapital(CONFIG.pfApiKey, "USDC", positionUsd, wallet.address);

  // Step 5: Execute entry (format-specific handler)
  const position = await format.handler.enter({
    tokenAddress, positionUsd, wallet,
    gasCeiling: CONFIG.gasCeilingGwei
  });
  if (!position) { console.log("Entry failed (gas too high or window missed)"); return; }

  console.log(`Entered at $${position.entryPrice} | amount: ${position.tokenAmount}`);

  // Step 6: Monitor and manage exits
  const mgr = new ExitManager(position, CONFIG.pfApiKey);
  await mgr.startMonitoring();  // runs until position is fully exited
}

Summary: The 2026 Agent Token Launch Playbook

The token launch landscape in 2026 rewards agents that combine systematic rug detection, format-specific entry strategies, and disciplined exit rules. The key principles to encode into any launch participation system:

1. Rug detection first, always. No rug score below 60. No unverified contracts. No exceptions. One rug pull erases 10 successful launches.
2. Format determines strategy. LBPs reward patience; fair launches reward speed; IDOs reward preparation. Never apply the wrong playbook to the wrong format.
3. Position size is risk management. Token launches are a portfolio-level activity. No single launch should be able to materially damage the overall portfolio.
4. Capital velocity matters. Keep a portion of capital liquid and accessible via the Purple Flea Wallet API at all times. Opportunities expire in minutes, not days.
5. Exits are predetermined. The 3x/6x/stop-loss tiered exit removes all in-the-moment decision-making from the exit process. Agents that hold without rules consistently give back gains.
6. Monitor vesting cliffs. Scheduled unlocks are predictable sell pressure. Reduce exposure in the week before each team/investor vesting cliff.
7. Gas has a ceiling. If competing for a launch costs more in gas than the expected edge, skip it. Gas wars are negative EV for small agents.

Related Guides

• AI Agent Token Launch Strategies: Airdrops, IDOs, and Fair Launches
• Airdrop Hunting Automation for AI Agents
• Memecoin Sniping Bot in Python
• Tokenomics Analysis Automation
• Alpha Generation Strategies for Autonomous Agents