u/paulf280

If you're building anything that auto-buys fresh Solana launches — snipers, copy-traders, agents — you've probably hit the same wall I did: by the time you've got a position, you find out the launch was a coordinated cabal. The "different" wallets all share one funder, the deployer has rugged 13 of his last 14 tokens, there were bundles in the launch block, and there's nowhere near enough liquidity to actually exit.

So I built Cabal Hunter — a rug/cabal detection layer your code calls before the buy.

What one call checks (~2s):

• Funding traces — follows the SOL back to find wallets that look independent but share a funder (the cabal fingerprint)
• Deployer history — the creator's past launches and how many died (e.g. "14 launched, 13 dead")
• Same-block bundles — Jito bundles / snipes in the launch tx
• Coordinated dumps — wallets exiting together, live
• Wash-trading score + cohort hold % (snipers vs insiders)
• Exit-liquidity check — is there enough liquidity for you to get out, or are you the exit liquidity?

The design choice I actually care about: it returns a score, but every flag links to the on-chain tx behind it, and the response tells you how much it looked at (scan_complete / wallets_checked). The score is a starting point you verify, not a verdict you take on faith — your bot applies its own risk tolerance instead of inheriting mine.

Integration: plain REST, or an MCP server if you're wiring it into an agent (Claude/Cursor/etc). 100 free calls/month, no signup. After that it's $0.02/call.

Try it, no key needed:

curl "https://api.cabal-hunter.com/api/scan-cabal?mintAddress=<MINT>"

I'm a solo dev, it's live but still evolving. I'd genuinely value feedback on the detection logic, the API shape, or what you'd want it to flag that it doesn't yet. Tear it apart.

i run a little tool that traces who's behind a solana token before you buy — funding clusters, bundles, deployer history. the coin people looked up most this week was one called SS.

turned out the dev had already launched 10 tokens and all 10 were dead. SS made 11 — it graduated, then liquidity got drained to about 5k and it's sitting at a 3k mcap now.

what gets me is the contract checks wouldn't have flagged it. contract was fine, lp looked ok. the only tell was the deployer's history — you had to look at the wallet that made it and what it made before.

if you want to verify, the dev wallet is AoGefnxF5CbZvbd2cvxv4Ex1E5j86dqEjehazRuMcMFe on solscan, the graveyard's all there.

sharing because "check who the dev is, not just the contract" has saved me more than any other rule. how's everyone else filtering devs before aping — manually on solscan, or something automated?

Sharing an architecture pattern from building an LLM agent that executes on-chain trades autonomously — the failure mode generalizes to any agent that takes irreversible real-world actions (trading, payments, infra changes).

The failure mode: the LLM's decisions were fine; the executions were catastrophic. ~42% of actions led to total loss. Root cause wasn't reasoning quality — every input the model could see looked benign. The disqualifying signal lived in data the model had no access to and couldn't infer (on-chain wallet funding graphs: clusters funded from one source, buying in the same block, primed to dump). "Bigger model / better prompt" does nothing here — missing ground truth, not bad reasoning.

The fix — split decision from validation:

1. LLM = decision layer. Proposes an action from what it can reason about.
2. Deterministic = validation layer. Before the irreversible step, a non-LLM check computes ground-truth signals → structured verdict (numeric score + boolean flags). Threshold → veto. No LLM in the veto path — you don't want a model you can talk out of the safety check.
3. Policy/timing gate on top (don't act in the highest-risk window — first N minutes post-launch).

Result in testing: total-loss rate ~42% → ~0, without touching the model.

Generalizable takeaways:

• For irreversible actions, the LLM should propose, not commit. Commit behind deterministic guards.
• The dangerous failures are where visible inputs look fine but a hidden ground-truth signal disqualifies the action — find those signals, compute them deterministically.
• Expose the guard as a tool the agent calls, but keep the veto deterministic.

Curious how others structure the decision/commit boundary for high-stakes agents — formal policy layer? Eval gates pre-execution?

I've been building an autonomous agent that trades Solana memecoins — it scans new tokens, decides, and executes swaps with no human in the loop. The hardest part wasn't the decision-making. It was realizing that an autonomous agent will confidently execute a catastrophic action unless you give it a tool to check before it acts.

In early testing, ~42% of the tokens my agent bought rugged to zero. Not because the LLM was "wrong" — the tokens looked clean (verified contract, LP burned, no obvious whale). The risk lived entirely outside the model's reasoning: clusters of wallets funded from the same source, buying in the same block, set up to dump on whoever buys next.

What actually fixed it was a pre-execution tool call. Before the agent signs a swap, it calls a function that returns a structured verdict — a 0–100 risk score + flags (shared funding sources, same-block bundles, serial-rug deployer history). Over a threshold → it skips. Combined with an entry-timing gate, the rug rate dropped from ~42% to near 0.

The general pattern for anyone building agents that act: the model decides, but you want deterministic guardrail tools sitting between the decision and the irreversible action. A confident wrong execution is far more expensive than a wrong sentence — and "just prompt it better" doesn't cut it when money moves.

How's everyone here handling guardrails on autonomous execution? Separate validator/policy layer, confidence thresholds, human-in-the-loop for high-stakes calls? What's actually held up in production?

(I built the rug-check tool that does this — per the sub rules I'll drop the link in a comment if folks want it. The guardrail pattern is the actual point.)

The Cabal Hunter Tool

I kept drowning in browser tabs trying to vet a token before my bot bought it — RugCheck here, Solscan there, holder lists somewhere else. So I built one screen that does the whole on-chain read and hands you a single verdict, then made it one click to wire into a bot.

Screenshot is a real scan (token: PIP). Everything you need is on one page:

• Plain-English verdict up top — Exit-Liquidity Risk: HIGH. The dev is a serial rugger (22/23 past launches dead). No interpreting raw numbers.
• 8 on-chain checks, each pass/fail — shared-funder clusters, same-block bundles, coordinated dumps, single-wallet concentration, CEX false positives, deployer history. Green check or red flag, that's it.
• Exit-liquidity simulator — actual price impact if you sell 1 / 5 / 10 / 25 SOL into the current pool.
• Wallet bubble map — see coordinated clusters at a glance.
• Top holders + funding trace — one click through to Solscan.
• 0–100 cabal score so you can set a hard threshold in code.

The part that matters for this sub: at the bottom of every report there's now an "Integrate" button. Click it and you get the JSON API + an MCP config (Claude / Cursor / Eliza, or plain HTTP for any language). One call before a swap returns the score + verdict — so your bot rejects the launch before it signs, instead of you pasting mints by hand.

Free tier to test it against your own flow. I built it for my own sniper, so I'm genuinely curious how it holds up against other people's setups — happy to go deep on the detection logic in the comments.

Built this because my trading agent kept walking into coordinated rugs that every "contract is safe" check missed. The actual risk on Solana meme tokens isn't the contract, it's the wallets behind it — so I made an MCP server the agent can call before it commits to anything.

One tool, check_cabal_risk(mint). It traces the top holders' funding back to shared sources, flags wallets that bought in the same block (bundled launches), pulls the deployer's history of past rugs, and returns a 0–100 score plus the raw evidence (links to the actual Solscan txs, so the agent — or you — can verify instead of trusting the number).

Wiring it in is just:

{ "mcpServers": { "cabal-hunter": { "url": "https://api.cabal-hunter.com/mcp" } } }

Works in Claude/Cursor/Eliza. 100 free calls a month, no key, no signup. I run it against my own bot's entry logic so it's not a demo that only works on cherry-picked tokens.

Free visual version if you just want to eyeball a token: api.cabal-hunter.com/map?mint=<MINT>

Happy to take feedback on the tool schema / response shape — if there's a field your agent would want that I'm not returning, tell me and I'll add it. Have a great day.

Last time I posted this it was a holder-cluster tool. Since then I've taken every piece of feedback from this sub and other subs and turned it into the thing I wish existed before I ape anything. Paste any mint into api.cabal-hunter.com/map?mint=<MINT> — no signup, nothing to install. What it checks, in one scan: All docs and description at https://api.cabal-hunter.com

• 🔍 Funding trace — top holders walked back to shared funding wallets. Every cluster links the actual funding tx on Solscan.
• ⚡ Same-block bundles — wallets that bought in the exact same block (Jito-bundled launches that route around funding traces).
• 🚨 Coordinated dumps — ≥2 holders dumping a real chunk in the same block, caught in the act.
• ⛔ Deployer track record — resolves the dev on-chain (works post-graduation) and checks their past launches: "14 tokens, 13 dead."
• 🛡 CEX-noise filter — holders funded from the same exchange aren't a cabal; we exclude them so you don't get false positives from people who just withdrew from Binance.

Distribution & market intel:

• 🏦 CEX funding map — which exchanges actually funded the holders and % of supply each (Binance vs MEXC vs Revolut…). Labels are Helius-verified — we never guess an address.
• 👥 Cohort PnL — Snipers vs Insiders: what they bought, how much they've already dumped, and the SOL they've banked.
• 🔁 Wash-trade filter — catches fake volume (wallets round-tripping to farm trending lists).
• 💧 Exit liquidity — price impact of your sell before you buy. Will the pool absorb a 25 SOL exit or slip 25%?

For the bot builders:

• 🚨 Emergency dump webhooks — your bot subscribes to a mint; we push the instant a dump/rug starts so it can auto-exit. Push, not polling.
• ⛓ On-chain receipts — every red flag links to the underlying tx. Don't trust the score, verify it.
• JSON API + MCP server (Claude/Cursor/ElizaOS). 100 free queries/month, then $0.05 in USDC. No keys, no subscription.

What I want from you: break it. Paste a token you know was a cabal and tell me if it missed something, or a clean one and tell me if it cried wolf. The harshest comment gets taken most seriously — that's literally how every feature above got built. Honest feedback only, no shilling.

Last time I posted this it was a holder-cluster tool. Since then I've taken every piece of feedback from this sub and other subs and turned it into the thing I wish existed before I ape anything. Paste any mint into api.cabal-hunter.com/map?mint=<MINT> — no signup, nothing to install. What it checks, in one scan: All docs and description at https://api.cabal-hunter.com

• 🔍 Funding trace — top holders walked back to shared funding wallets. Every cluster links the actual funding tx on Solscan.
• ⚡ Same-block bundles — wallets that bought in the exact same block (Jito-bundled launches that route around funding traces).
• 🚨 Coordinated dumps — ≥2 holders dumping a real chunk in the same block, caught in the act.
• ⛔ Deployer track record — resolves the dev on-chain (works post-graduation) and checks their past launches: "14 tokens, 13 dead."
• 🛡 CEX-noise filter — holders funded from the same exchange aren't a cabal; we exclude them so you don't get false positives from people who just withdrew from Binance.

Distribution & market intel:

• 🏦 CEX funding map — which exchanges actually funded the holders and % of supply each (Binance vs MEXC vs Revolut…). Labels are Helius-verified — we never guess an address.
• 👥 Cohort PnL — Snipers vs Insiders: what they bought, how much they've already dumped, and the SOL they've banked.
• 🔁 Wash-trade filter — catches fake volume (wallets round-tripping to farm trending lists).
• 💧 Exit liquidity — price impact of your sell before you buy. Will the pool absorb a 25 SOL exit or slip 25%?

For the bot builders:

• 🚨 Emergency dump webhooks — your bot subscribes to a mint; we push the instant a dump/rug starts so it can auto-exit. Push, not polling.
• ⛓ On-chain receipts — every red flag links to the underlying tx. Don't trust the score, verify it.
• JSON API + MCP server (Claude/Cursor/ElizaOS). 100 free queries/month, then $0.05 in USDC. No keys, no subscription.

What I want from you: break it. Paste a token you know was a cabal and tell me if it missed something, or a clean one and tell me if it cried wolf. The harshest comment gets taken most seriously — that's literally how every feature above got built. Honest feedback only, no shilling.

Hey everyone,

Like pretty much anyone trading on Solana lately, I’ve been getting absolutely rinsed by bundled launches and coordinated wallet clusters. A dev launches a token, splits the supply across 20 seemingly unrelated fresh wallets, and dumps them completely out of nowhere.

Standard checkers usually look at top holders, but they miss the wallets that were secretly funded by the same deployer or a centralized master wallet right before launch.

I got sick of it, so I spent the last few months building an on-chain mapping tool called Cabal-Hunter to visually trace wallet funding sources and group them into clusters.

It generates a bubble map to show exactly who is connected to who, and spits out a "Cabal Score" based on how much of the supply is controlled by these coordinated clusters.

The web map visualizer is live at:https://api.cabal-hunter.com/map?mint=Dvy3P3k8zoUENhiUZGWRsJJCz97Ps9cng2LxjM77pump(this is just a random live token map for reference).

I’m looking for some completely honest feedback from the traders here:

1. Does mapping out the funding sources actually give you enough warning before a dump, or are we too far gone in the meta?
2. If you look at the map layout, is it clean enough to make a 5-second decision while trading? What metrics am I missing in the sidebar?

Be as critical as you want. Just trying to build something genuinely useful for the community. Cheers!

Hey everyone,

If you’re trading in the trenches here, you already know the worst feeling is finding a solid entry on a new coin, only to realize a few minutes later that you just provided exit liquidity for a coordinated cluster of insider wallets.

I couldn't find an infrastructure tool that visualized these connections quickly enough, so I spent the last while building one called Cabal-Hunter. It maps out coordinated wallet behavior on-chain so you can see if a "community takeover" is actually just 20 wallets controlled by the same group getting ready to dump.

I'm at the point where the tool works, but I need some unfiltered feedback from people who are actively trading meme coins every day to see if it actually holds up in the wild.

I'd love to know:

• Does the data load fast enough for the speed of meme coin launches?
• Is the UI intuitive when you're rushing to check a CA before aping in?
• What red flags are you looking for that the tool might be missing?

If you actively trade and want to tear my UI apart or test its limits, let me know in the comments and I’ll shoot you the link. No catch, I just genuinely need real traders to give it a test drive.