Tracking pump.fun launches from your AI agent in real time

pump.fun is the highest-volume token launchpad on Solana, producing between 10,000 and 50,000 new mints per day depending on the market regime. Almost all of them are noise. A small subset — measured by sniper activity, holder growth velocity, dev-wallet pedigree, and KOL involvement — are the ones worth a $50-500 entry within the first 15 minutes.

This post wires an AI agent (running in Cursor for live iteration, deployable to a server when ready) to the techkern MCP server, queries the pump.fun feed in real time, and demonstrates a few strategy primitives — fresh-launch triage, sniper concentration screen, and KOL-cross-reference alerts.

The techkern pump.fun MCP tools

After installing techkern MCP, your agent gets:

• query_pump_fun_launches(window_minutes?, min_holders?, min_mcap_usd?) — fresh launches
• mint_authority_check(mint) — revocation status
• holder_distribution(mint) — top-N + dev-wallet hold %
• dev_token_history(wallet) — full historical launch log
• query_kol_wallets(window_minutes?, min_size_usd?) — recent tracked-KOL buys
• new_token_alerts(min_holders?) — fresh mints crossing thresholds

All return structured JSON, indexed in ClickHouse from a custom pump.fun listener on the bonding-curve program. Indexer lag: ~300ms behind chain tip. Query p95: 41ms.

Primitive 1 — Fresh-launch triage

The most common workflow. Every 60 seconds, pull all pump.fun launches less than 15 minutes old with at least 30 holders, then run a fast filter pass to drop anything obviously rugged.

Every 60s:
  candidates = query_pump_fun_launches(window_minutes=15, min_holders=30)
  for c in candidates:
    auth = mint_authority_check(c.mint)
    if auth.mint_authority != "revoked": skip
    holders = holder_distribution(c.mint)
    if holders.dev_balance_pct > 80: skip  // dev still holds too much
    if holders.dev_balance_pct < 5: skip  // dev dumped — likely already rugged
    surviving.append({ ...c, ...holders })

That whole loop is eight lines of prompt. The agent calls 2-3 MCP tools per candidate. On Hobby tier (1K queries/day) you can poll every 90 seconds across the top 20 candidates and stay inside quota.

Primitive 2 — Sniper concentration screen

Snipers are the first-block buyers — usually bots that grab 1-3% of supply in the launch transaction's same block. A few snipers per launch is normal. Twenty snipers controlling 40% of supply means coordinated sniping, which historically correlates with coordinated dumps within the first hour.

For each fresh launch:
  holders = holder_distribution(c.mint, top_n=50)
  sniper_count = count(h for h in holders if h.first_block_buy)
  sniper_supply_pct = sum(h.pct for h in holders if h.first_block_buy)
  if sniper_count > 15 and sniper_supply_pct > 35:
    skip  // coordinated sniper cluster — high dump risk

Six lines. The agent now drops the worst sniper-cluster tokens before they hit your alerts list.

Primitive 3 — KOL-cross-reference alerts

Some launches get one or two known-alpha KOL wallets entering early. When that happens on a launch with otherwise-clean signals, it is one of the highest-EV setups on the platform.

Every 5m:
  recent_kol_buys = query_kol_wallets(window_minutes=10, min_size_usd=1000)
  for buy in recent_kol_buys:
    if buy.mint in pump_fun_universe:
      launch = lookup_launch(buy.mint)
      if launch.age_minutes < 30 and launch.holders > 50:
        alert("KOL " + buy.wallet + " entered " + buy.mint + " at " + buy.size_usd)

The agent does cross-wallet polling. query_kol_wallets returns structured buy events with timestamps, sizes, and tagged-wallet handles. You can paper-trade against the alerts for a week to verify the edge persists, then turn on live execution.

Why this is faster than direct RPC

You could subscribe to the pump.fun bonding-curve program directly via Solana RPC. It is public, well-documented (the program is open source), and free with a Helius account. The reason you do not want to:

• Account-subscription management — Solana account subs are stateful; reconnects are tricky
• Decoding — every bonding-curve event has to be parsed from raw account state changes
• Indexing — you need to write the data to a queryable store to do anything more than tail it
• Cross-mint joins — you cannot ask "which of these mints has KOL involvement" from a single account sub

Techkern's indexer subscribes once, writes to ClickHouse with full replay support, and exposes the data via MCP. Your agent gets the same data with none of the operational tax. 8.4M+ queries served today, across 2,341 connected agents.

Latency budget

For a strategy that needs to react inside one Solana slot (~400ms):

• Slot finalization → indexer write: 250-350ms
• Agent polls MCP: 30-50ms (p95 41ms)
• Agent reasoning: 200-500ms (model-dependent)
• Total agent reaction time: ~500-900ms

That is competitive for fresh-launch sniping at the "minute-1-to-minute-15" stage. For first-block sniping (~50ms window) you still want direct RPC + co-located execution. MCP is for the strategy layer above first-block — alpha discovery, triage, KOL-mirror, alerting.

Putting it together

The minimum viable pump.fun-aware agent is:

> Run forever. Every 60 seconds: pull pump.fun launches in the last 15 minutes with at least 30 holders. For each, check mint authority is revoked, dev hold is between 5% and 80%, and sniper concentration is under 35%. Drop the rest. Every 5 minutes: pull the last 10 minutes of KOL wallet buys; for any that hit a pump.fun mint < 30 min old with > 50 holders, alert me with the KOL handle and entry size.

Paste that into a Claude conversation with techkern MCP installed. Run it. You now have fresh-launch triage + KOL-cross-reference deployed in under a minute, with zero infrastructure on your side.