How Ruggy works

Ruggy is a machine-learning model trained from scratch, in public, to estimate how likely a fresh pump.fun coin is to be rugged. This page explains what it looks at, how it learns, how it is measured and where it is weak.

How Ruggy works

Every coin goes through the same loop:

• A coin launches on pump.fun. Ruggy's indexer sees it within seconds and starts recording its trades.
• The enricher pulls wallet signals: who funded the first buyers, the dev's past coins, how concentrated the holders are, and how many wallets bought in the very first block.
• The model scores the coin at 1, 5 and 15 minutes after launch. Each score comes with the top reasons behind it.
• The score goes out live to the site, the lab, the stream and the bots.
• 24 hours after launch, the labeler writes down what really happened.
• Every night Ruggy retrains on the new labels. A new model goes live only if it beats the current one on coins it has never seen.

You can watch all of it on the lab: live scores, the training run, the console log, and the coins Ruggy got right and wrong.

Scores and levels

A score is a rug risk from 0 to 100. From a trained model it is a calibrated probability: across many coins scored 80, roughly 80 in 100 should end up labeled rug. Scores from heuristic-v0 (see below) are rule weights, not calibrated probabilities. Each score maps to a level, and every level is shown as a word as well as a colour.

Coins are scored at three checkpoints: 1m, 5m and 15m after launch. A score at a checkpoint uses only what had happened by that moment. If you check an older coin Ruggy has not seen, it is scored at its current age and the report says so (“scored at minute 42”). When a coin has too little activity to judge, Ruggy shows “Not enough to sniff yet” instead of a confident number.

On-chain risk (risk-v1)

Every report also shows a second number: on-chain risk, from 0 to 100. It comes from risk-v1, a fixed set of written rules over on-chain data, and it is separate from the model. It does not use the model score, crowd predictions or any AI. The model asks “how likely is a rug label at 24 hours?”; risk-v1 asks “which known risk patterns are in the data right now?”. The two can disagree, and both are shown with their own label.

• Rules: mint and freeze authority, risky Token-2022 extensions, the creator's launch allocation and selling, wallets the creator funded after launch, the creator's earlier coins labeled rug and launch rate, top-10 and top-holder concentration, multi-wallet buy transactions, creation-slot buyers and their supply, snipers, shared funders among early buyers, supply held by a funding cluster, fresh wallets, known crews, the creator cluster's share of selling, and a price collapse after a run-up.
• Points: each rule has fixed tiers with points and a severity. The score is the sum of the triggered points, capped at 100. A set mint or freeze authority is critical and lifts the category to at least high.
• Categories: low (under 20), moderate (20 to 44), high (45 to 69), very high (70 and up). When less than half of the possible points could be evaluated, the category is “not enough data”, never “low”: a coin with almost no trades has not shown anything yet.
• Each rule reports whether it triggered, was clear, or had not enough data (with the reason), the measured value against its threshold, its evidence level, the transactions and wallets behind it (Pro), its limits, and how it is measured.
• Point in time: a result at a checkpoint uses only data visible at that moment. Results are stored at every checkpoint next to the model score.
• Versioned: every result carries the rules version and a methodology hash. A changed rule set is a new version; stored results are never rewritten.
• Not covered yet: LP concentration and removal, authority history, wash trading, and the creator co-signing another wallet's buy (the findings block covers that one). They are left out rather than guessed.

Thresholds are starting values chosen by hand and are not fitted to labels yet. On-chain risk describes what the data shows, not intent. It is not an accusation and not financial advice, and risk is not the same as profitability.

Labels

Ruggy learns from outcomes, so the outcome definition matters. At 24 hours each coin gets one of three labels:

• Rug. The coin reached at least $8k market cap, ended below a tenth of its peak, and the dev's wallet cluster sold at least half of what it held. Or the coin reached at least $8k, the dev cluster sold 80% or more of its holdings within an hour of launch, and the price fell 70% or more from its peak within 15 minutes of that selling.
• Survived. The coin ended above $30k market cap, or it graduated from the bonding curve and kept at least 40% of its peak.
• Died. Everything else: no traction, or a slow bleed without a cluster dump.

The “dev cluster” is the creator wallet, wallets linked to it by funding transfers within three hops (exchange hot wallets excluded), and first-block buyers that share a funder with any of them. The model is trained to tell rugs apart from everything else; survived and died both count as “not a rug”.

What Ruggy looks at

Every feature is computed only from data that existed at the checkpoint. Missing data stays missing; it is never filled in with zero.

• Dev: initial buy, wallet age, where the wallet got its SOL, past launches and how many were labeled rug, how much the dev has sold so far.
• Bundles: buyers in the creation block, the share of supply they took, buyers that share a funder, the largest funding cluster, fresh and exchange-funded buyers.
• Holders: holder count, top-1 and top-10 share, inequality, and how fast new holders arrive.
• Trading: trades, unique traders, buy/sell balance, net SOL flow, volume, market cap, drawdown from the peak, and how much of the selling comes from clusters.
• Crews and early buyers: whether a known crew is in, how its past coins ended, and the track record of the wallets that bought in the first minutes.
• Social (when enabled): links, website age, comment activity and duplicate comments, paid DexScreener profile or boosts, X mentions.
• Meta: ticker collisions in the last 24 hours, reused images, launch hour.

The lab shows which features move the live model most. Each report lists the top reasons for that coin, and Pro shows the full feature table with each feature's contribution.

Training and metrics

Ruggy uses a gradient-boosted tree model (LightGBM), one per checkpoint, retrained nightly. Data is always split by time, never at random: the newest 24 hours of labeled coins are the holdout, the 24 hours before that are for validation, and the 30 days before that are for training. That way the model is always tested on coins from after everything it learned from.

The numbers on the lab and in the changelog are computed on that holdout:

• PR-AUC, the main metric: how well the model ranks rugs above non-rugs when rugs are the minority.
• ROC-AUC: the chance a random rug scores higher than a random non-rug.
• Precision and recall at 70: of the coins scored 70 or more, how many were rugs; and of all rugs, how many scored 70 or more.
• Brier score and calibration error: how close the scores are to real frequencies. Lower is better.

A new model is promoted only if its PR-AUC beats the live model by at least 0.005 on the same holdout, its calibration error stays at or under 0.05, and its precision at 70 does not drop by more than 0.02. Rejected models stay on the changelog with the reason.

Before there are enough labels (3,000 eligible coins, at least 300 of them rugs), Ruggy runs heuristic-v0: a transparent set of weighted rules over the same signals. Every score from it carries a “Heuristic mode” badge with the current label count.

Graduation chance

A second model, trained the same way, estimates the chance that a coin graduates from the pump.fun bonding curve within 24 hours. It is shown next to the rug risk (“Graduation chance 18%”). The two numbers answer different questions: a coin can graduate and still be rugged later.

Crews and the radar

A crew is a group of wallets that keeps acting together across coins: shared funders, buying in the first blocks of the same launches, selling within a minute of each other. Crews get stable ids and neutral names like “Crew Amber Heron #12”, and their own pages with the coins they touched and how those coins ended.

When a known crew launches a coin or buys in its first block, or a dev with at least two earlier rugs launches a new one, the radar fires within seconds, before the first score. Radar lines state facts, for example “9 of their 12 previous coins rugged”. They are not accusations against any person.

Story checks

Paste an X post or a website and Ruggy reads the claims in it (“partnered with…”, “audited”, “LP locked”, “doxxed team”) and checks each one against evidence: on-chain facts, listing sites, the linked website and its domain age, the poster's account, and the claimed partner's or auditor's own site when the post links to it. Each claim gets one verdict:

• Verified: the evidence supports it, with a source link.
• Unverified: Ruggy found nothing either way.
• Contradicted: the evidence says otherwise, with a source link.

The overall story verdict follows a fixed rule: any contradicted claim makes it Contradicted, otherwise any unverified claim makes it Partly unverified, otherwise it Checks out. The story verdict sits next to the coin score: COIN: RUG RISK 91 · STORY: CONTRADICTED. It never changes the model score.

AI explanations

Reports open with a short explanation. For Pro it is written by a language model when the server has one configured; otherwise, and for free users without a cached AI text, it is a plain template built from the same facts and labeled as such. Scoring never uses a language model. The writer gets a fact sheet built from Ruggy's data (score, top drivers, clusters, dev, holders, market, crews, gaps in the data) and nothing else. It must not add facts, numbers or advice. Every number in its text is checked against the fact sheet; if one does not match, the text is rewritten once and otherwise replaced with a plain template. AI-written text is always labeled “Explained by AI from Ruggy's data”. Ask Ruggy, the chat on reports, follows the same rules.

Limits and blind spots

• Ruggy is often wrong. Misses and false alarms are shown on the lab as prominently as hits, and the running accuracy is computed, not typed in.
• The first minute has little data. A 1m score can move a lot by 5m or 15m.
• A careful dev who funds wallets through exchanges or many hops can look organic. Funding links are traced up to three hops.
• Rugs that happen after 24 hours, or slow bleeds without a cluster dump, are not labeled rug.
• Social signals depend on optional providers. When one is off, the report says so and the feature is left empty.
• The market changes. A model trained on last month's tricks can lag behind this week's. Nightly retraining narrows that gap; it does not close it.

Think Ruggy got one wrong? Use “Report a miss” on the report. The labeler checks it at 24 hours, and accepted reports earn points and a credit in the changelog.

Data sources

Ruggy reads public data only and runs no smart contracts of its own.

• Solana mainnet: pump.fun and PumpSwap program events, trades, SOL transfers and token accounts, from a live stream and RPC providers.
• Prices: the SOL/USD price from Jupiter, on-chain WSOL/USDC swaps and, for older minutes, a Binance reference.
• Optional providers (only when the operator enables them): DexScreener profiles and boosts, Bubblemaps as a cross-check (never used for scoring), X mentions, pump.fun comments, coin metadata and images over IPFS.
• Historical research data: a derived subset of Solarchive (mirror data.solarchive.org), partitions txs/2025-11-01 to txs/2025-12-05, licensed CC BY 4.0. The subset is a derived work: transactions were filtered to the pump.fun bonding-curve program, PumpSwap, SOL transfers and WSOL/USDC pool legs, and the trade rows were reconstructed from balance changes by Ruggy's research scripts. Solarchive did not produce these rows and does not endorse them. Anything redistributed from this subset keeps this attribution and is shared under CC BY 4.0 terms.

Plans

The live feed, the lab and basic checks are free. Free reports show the verdict, the market, a holders summary and two reasons. Pro adds the full report (clusters, dev deep-dive, trading behaviour, socials, similar coins, raw signals), unlimited explanations, up to 200 Ask Ruggy questions a day, real-time alerts at any threshold, a wallet monitor, a 100-coin watchlist, exports and an API key. Pro is sold as 30-day passes paid with SOL through Solana Pay, verified on-chain, with no auto-renew. Limits are enforced on the server. See Pro.

Games

“Bundled or not?” and “Rug or run?” on the play page are for points only. There are no deposits, no wagers, no paid entry and no prizes, and nothing on Ruggy is a bet. Bundle answers are judged by a fixed on-chain rule, not by the model; rug-or-run calls are resolved by the same 24-hour labeler.

Privacy

Ruggy stores wallet addresses and public handles. Google sign-in keeps only your Google account id and email, for recovery. Telegram chat ids are kept only to send the alerts you asked for. There are no analytics and no third-party trackers. Your IP address is used for rate limits and appears only in short-lived server logs. You can delete your account from your account page.

Disclaimers

Model output, not financial advice.

Ruggy describes signals and probabilities, such as “91% rug risk” or “dev wallet sold 84% within 9 minutes”. It never calls a person or a wallet a scammer, and dev and crew pages show on-chain facts only. A low score does not mean a coin is safe, and a high score does not mean anyone did anything wrong. Do your own research and never trade more than you can afford to lose.