DEV Community

Gerus Lab
Gerus Lab

Posted on

How We Built an AI-Powered Trend Detection Engine for Solana Meme Coins

#ai #solana #web3 #typescript

Every 30 seconds, a new token launches on Solana. Most die within hours. A few explode 100x. The difference? Timing and signal detection.

We built Mememind — a real-time AI engine that analyzes forming trends across Twitter, Telegram, and on-chain data to identify meme coin opportunities before they pump. This project came directly from our experience building AURON — a high-performance Solana launcher and trading terminal. After shipping the launch side, we realized the detection side was an even bigger problem. Here's how the architecture works under the hood.

The Problem With Manual Trading

If you've ever tried to trade meme coins manually, you know the drill:

  • By the time you see a token trending on Twitter, it's already up 500%
  • Telegram alpha groups are noisy — 95% garbage signals
  • On-chain data tells the real story, but parsing it in real-time is brutal

We needed a system that could ingest multiple data streams, cross-reference signals, and surface actionable intelligence in under 10 seconds.

Context: From AURON to Mememind

Before Mememind, we built AURON (docs) — a Solana trading terminal that solves the latency and complexity of manual trading. AURON provides a single dashboard to control hundreds of wallets, execute snipe or bundle purchases in the same block as a token launch, and automate post-launch trading strategies for volume generation.

Under the hood, AURON uses a gRPC listener (@triton-one/yellowstone-grpc) for millisecond-level on-chain updates. It includes a custom Platform Factory that abstracts away the differences between Pump.fun and Raydium, and supports multiple transaction submission strategies: Jito Bundles, Astralane, and Quicknode Lil-JIT.

Building AURON taught us how the launch pipeline works from the inside:

  • How liquidity pools get created on Raydium and Pump.fun
  • Which on-chain patterns indicate a legitimate launch vs a rug
  • How wallet distribution and initial buy patterns affect price action
  • How Jito bundles work at the instruction level

That knowledge became the foundation for Mememind's detection engine. When you've built the tool that launches tokens, you know exactly what signals to look for in other launches.

Architecture Overview

The stack is surprisingly lean:

[Data Ingestors] → [Signal Processor] → [AI Scoring Engine] → [Dashboard]
     │                    │                      │
  Twitter API         Redis Streams          Claude API
  Helius WS           Bull Queues            Custom prompts
  TG Bot API          Dedup layer            Confidence scoring
Enter fullscreen mode Exit fullscreen mode

Data Layer: gRPC + Twitter Firehose

For on-chain data, we reuse the same approach from AURON — a gRPC listener via @triton-one/yellowstone-grpc that gives us millisecond-level updates on pool creation events. This is significantly faster than WebSocket subscriptions:

import { Client } from '@triton-one/yellowstone-grpc';

const client = new Client(GRPC_ENDPOINT, GRPC_TOKEN);
const stream = await client.subscribe();

stream.on('data', (update) => {
  if (isPoolCreation(update)) {
    const meta = extractPoolMeta(update);
    signalQueue.add('new-pool', {
      mint: meta.tokenMint,
      liquidity: meta.initialLiquidity,
      creator: meta.authority,
      timestamp: Date.now(),
      platform: detectPlatform(update), // pump.fun or raydium
      isBundled: detectJitoBundle(update),
    });
  }
});
Enter fullscreen mode Exit fullscreen mode

The detectPlatform function comes straight from AURON's Platform Factory — the same abstraction layer that handles differences between Pump.fun and Raydium for launching tokens now identifies which platform a new token was launched on.

The detectJitoBundle check is something we added for Mememind: if a launch was submitted as a Jito bundle (atomic, MEV-protected), it's typically a more sophisticated team behind it. This feeds into our scoring engine.

Twitter data comes through keyword tracking — we monitor ~200 crypto-related terms and filter by engagement velocity (likes/minute, not absolute count).

Signal Processing: The Cross-Reference Engine

A single signal means nothing. A token appearing on-chain AND getting Twitter mentions AND showing wallet accumulation — that's a pattern.

We score each token across 5 dimensions:

  1. On-chain momentum — Buy/sell ratio in first 5 minutes
  2. Social velocity — Tweet rate acceleration (not volume)
  3. Wallet intelligence — Are known profitable wallets accumulating?
  4. Liquidity health — Is liquidity locked? Bundle or manual launch? Creator wallet behavior
  5. Narrative fit — Does the token name/theme match a forming trend? 
interface SignalScore {
  onChain: number;      // 0-100
  social: number;       // 0-100
  walletIntel: number;  // 0-100
  liquidity: number;    // 0-100
  narrative: number;    // 0-100
  composite: number;    // weighted average
  confidence: 'low' | 'medium' | 'high';
  launchMethod: 'jito-bundle' | 'astralane' | 'manual' | 'unknown';
}
Enter fullscreen mode Exit fullscreen mode

Dimension #4 (Liquidity health) directly uses patterns we identified while building AURON. For example: bundled launches (Jito, Astralane, Lil-JIT) score higher on legitimacy because they indicate technical sophistication. We can detect the submission method by analyzing transaction structure and checking for tip transfers to known Jito tip accounts.

AI Scoring: Where Claude Does the Heavy Lifting

The narrative scoring is where AI shines. We feed Claude a structured prompt with:

  • Current trending topics (last 4 hours)
  • Token metadata (name, symbol, description)
  • Similar tokens that pumped recently

Claude returns a narrative score and a one-line "meme thesis" explaining WHY this could trend. This is something no purely quantitative model can do — understanding internet culture requires reasoning, not just math.

const narrativeAnalysis = await claude.messages.create({
  model: 'claude-sonnet-4-20250514',
  messages: [{
    role: 'user',
    content: `Analyze this token's meme potential:
      Name: ${token.name}
      Symbol: ${token.symbol}
      Launch method: ${token.launchMethod}
      Current trending topics: ${trendingTopics.join(', ')}
      Recent successful memes: ${recentWinners.map(w => w.name).join(', ')}

      Score 0-100 on narrative strength. Explain in one sentence.`
  }]
});
Enter fullscreen mode Exit fullscreen mode

The Dashboard: Next.js + Real-Time Updates

The frontend is a Next.js app with server-sent events for live updates. Every new scored token appears instantly with its composite score, AI reasoning, and a one-click link to the DEX.

We kept the UI intentionally dense — traders want information density, not whitespace. Think Bloomberg terminal, not Stripe dashboard.

Key design decisions:

  • No pagination — infinite scroll with virtualized list (react-window)
  • Color-coded confidence — green/yellow/red at a glance
  • AI reasoning visible — the "why" matters as much as the score
  • Launch method badge — shows if token was bundle-launched (connects to AURON's detection logic)
  • Historical accuracy — every past signal shows if it hit or missed

What We Learned

1. Speed beats accuracy. A 70% accurate signal in 10 seconds beats a 95% accurate signal in 5 minutes. Meme coins move FAST.

2. AI is better at culture than code. The quantitative signals were straightforward engineering. The narrative analysis — understanding that a token named "DOGWIFHAT" will resonate because of an existing meme — that's where AI was irreplaceable.

3. gRPC > WebSockets for Solana. We started with Helius WebSockets but switched to yellowstone-grpc (same stack as AURON). The latency difference is 50-200ms vs 1-5ms. For meme coin detection, those milliseconds matter.

4. Don't trust any single signal. The cross-referencing approach caught us off guard — it works way better than any individual indicator. The composite score's win rate is ~40% higher than any single dimension.

5. Build both sides of the pipeline. Having AURON (the launch tool) gave us an unfair advantage building Mememind (the detection tool). When you understand how tokens are created at the instruction level — how Platform Factory abstracts Pump.fun vs Raydium, how Jito bundles are structured — detecting them becomes pattern matching, not guesswork.

Performance Numbers

After 3 weeks of live testing:

  • Average detection-to-alert latency: 8.2 seconds
  • Signal accuracy (token did at least 2x): 34%
  • Top quartile accuracy (composite > 80): 61%
  • False positive rate: ~22%

34% overall might sound low, but in meme coin trading, a 2:1 reward-to-risk with 34% accuracy is massively profitable.

Stack Summary

Component Tech
Backend Node.js + TypeScript
Queue Redis + BullMQ
AI Claude API (Sonnet for speed)
On-chain yellowstone-grpc (same as AURON)
Frontend Next.js 16 + SSE
Deployment VPS + systemd

Wrapping Up

Building Mememind taught us that the best AI applications aren't chatbots — they're invisible intelligence layers that process data humans can't handle at speeds humans can't match. And the best detection tools come from understanding the creation pipeline first — which is exactly what we learned building AURON.

The two products are complementary: AURON handles the launch and trading execution, Mememind handles the intelligence and signal detection. Together they cover the full token lifecycle.

If you're working on something similar in DeFi, Web3, or AI-powered analytics — we've been shipping these kinds of systems at Gerus-lab. Always down to talk architecture.

Links:

Built by the team at Gerus-lab — an engineering studio specializing in AI, Web3, and SaaS development.

Top comments (0)