Production-grade autonomous threat detection for crypto traders and DeFi protocols.
| Website | fud-ai.vercel.app |
| Docs | fud-ai.vercel.app/docs |
| Hire via CROO | agent.croo.network/agents/4799b7fe... |
| Video Walkthrough | YouTube Demo |
| X (Twitter) | x.com/fuddulu |
| GitHub | github.com/chulopp/FUD.ai |
Crypto markets don't just move on news — they move on manufactured fear. Coordinated FUD campaigns, sybil-driven sentiment attacks, and whale-orchestrated rug-pulls can wipe out positions before any human can react.
FUD.ai is an autonomous intelligence agent that solves this. It fuses on-chain evidence, social signals, and explicit coordination detection — then reasons across multiple adversarial scenarios using an MCTS-inspired epistemic engine — to deliver a single, immediately actionable verdict.
The agent is callable by any bot or automated system via the CROO CAP protocol with pay-per-call, on-chain settlement on Base. No subscriptions, no monthly commitment.
| General AI | Sentiment Aggregator | FUD.ai | |
|---|---|---|---|
| On-chain grounding | None | Inconsistent | GoPlus + RugCheck + DexScreener + Bybit order book |
| Coordination detection | None | Not explicit | Author ratio + duplicate-text clustering + burst windows |
| Reasoning | Single answer | Score aggregation | 3 parallel MCTS branches with probability distribution |
| Self-correction | No memory | No memory | Reflexion loop — learns from past misses |
| Agent-to-agent | Not native | Not native | CROO CAP native, on-chain settlement |
$0.02 USDC per call. Pay-per-call via the CROO CAP protocol on Base mainnet — settlement is on-chain and automatic. You only pay for successful analyses. No subscription, no monthly fee, no minimum commitment.
- Trader Bots — Verify whether a sudden price drop is organic or a coordinated FUD attack before triggering stop-loss orders.
- Copy-Trading Guards — Screen positions before copying a wallet: detect if the asset is being set up for a rug-pull or whale exit.
- DeFi Protocol Monitoring — Continuously monitor your TVL token for coordinated social manipulation that typically precedes a bank run.
- On-chain Analysts — Augment manual research with a multi-source, adversarially-reasoned threat score for any EVM or Solana token.
- Alert Systems — Feed verdict signals into Telegram bots, Discord notifications, or custom dashboards to surface threats proactively.
FUD.ai is built on an async job pattern designed for reliability under heavy computational load.
┌─────────────┐ POST /api/agent ┌───────────────┐
│ Requester │────────────────────────▶│ Next.js API │
│ (Bot/Agent) │◀─── 202 + job_id ───────│ (Vercel) │
└─────────────┘ └───────┬───────┘
│ │ enqueue → Redis
│ GET /api/agent/{job_id} (poll 2-3s) │
└──────────────────────────────────────▶ ▼
┌───────────────┐
│ CROO Worker │
│ (EC2 / VPS) │
└───────┬───────┘
│ MCTS Pipeline
┌────────────┼────────────┐
▼ ▼ ▼
┌──────────┐ ┌──────────┐ ┌──────────┐
│ On-chain │ │ Social │ │ Market │
│ GoPlus │ │ Twitter │ │ Bybit │
│ RugCheck │ │ Telegram │ │ DexScr │
│ CoinGecko│ │ (native) │ │ DefiLlama│
└──────┬───┘ └──────┬───┘ └──────┬───┘
└────────────┼────────────┘
▼
┌───────────────┐
│ Coordination │
│ & Sybil Detect│
└───────┬───────┘
▼
┌───────────────┐
│ MCTS Reasoning│
│ Branch A/B/C │
│ + Reflexion │
└───────┬───────┘
▼
┌───────────────┐
│ Upstash Redis │
│ (job store) │
└───────────────┘
- Async, not synchronous — The full pipeline can take up to 150 seconds.
POST /api/agentreturns202 + job_idin < 1 second; the pipeline runs in the background and writes results to Redis. - Upstash Redis (REST-based, not TCP) — serves as job store, concurrency limiter, and ingestion cache. No Redis server to manage.
- MCTS reasoning engine — evaluates three parallel scenarios (Real Crash / False FUD / Whale Manipulation) against the evidence chain, producing a probability distribution and a dominant branch.
- Reflexion loop — records every verdict. When a past prediction is wrong, the loop extracts what the evidence missed and recalibrates confidence for similar future cases.
- CROO provider worker — a separate process (
scripts/croo-provider-worker.ts) connects to the CROO CAP WebSocket and handles agent-to-agent settlement on Base. Deploy as a single replica (CROO enforces 1 API Key = 1 WebSocket).
- Node.js 20+ and npm
- An Upstash Redis instance (upstash.com — free tier works)
- API keys for at least one LLM engine (OpenRouter or Gemini or DeepSeek)
- Optional: CROO SDK key (for production agent-to-agent settlement)
git clone https://github.com/chulopp/FUD.ai.git
cd FUD.ainpm installcp .env.example .env.localCore environment variables:
# ─── LLM Engines (at least one required) ───
OPENROUTER_API_KEY=
GEMINI_API_KEY=
DEEPSEEK_API_KEY=
DEEPSEEK_BASE_URL=https://api.deepseek.com
# ─── Upstash Redis (job store + cache + concurrency) ───
UPSTASH_REDIS_REST_URL=
UPSTASH_REDIS_REST_TOKEN=
# ─── On-Chain & Market APIs ───
BYBIT_API_KEY=
BYBIT_API_SECRET=
GOPLUS_APP_KEY=
GOPLUS_APP_SECRET=
RUGCHECK_API_KEY=
COINGECKO_API_KEY=
# ─── Social Scrapers ───
RAPIDAPI_KEY=
RAPIDAPI_HOST=twitter-api45.p.rapidapi.com
# Telegram: no credentials needed (public web scraping)
# ─── CROO CAP Protocol (production agent-to-agent) ───
CROO_API_URL=https://api.croo.network
CROO_WS_URL=wss://api.croo.network/ws
CROO_SDK_KEY=croo_sk_...npm run devOpen http://localhost:3000 for the landing page + live demo. Open http://localhost:3000/docs for the documentation.
For production agent-to-agent settlement via CROO CAP:
npm run croo:workerNote: Deploy this worker as a single replica. CROO enforces 1 API Key = 1 WebSocket connection — duplicate instances get disconnected with code 1008.
FUD.ai is designed as two independently deployed components:
The Next.js application handles the UI, MDX documentation, and /api/agent REST endpoints.
- Connect your GitHub repository to Vercel.
- Add all environment variables from
.env.examplein Vercel Project Settings. - Ensure
UPSTASH_REDIS_REST_URLandUPSTASH_REDIS_REST_TOKENare set — the frontend writes job records to Redis that the worker reads.
The CROO worker (scripts/croo-provider-worker.ts) is a persistent long-running Node.js process — not an HTTP server. It connects to the CROO CAP WebSocket and executes the MCTS pipeline for each paid order.
Recommended: AWS EC2 t2.micro (Free Tier) + PM2
# On your EC2 instance (Ubuntu 24.04 LTS):
# 1. Install Node.js 20 + PM2
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt-get install -y nodejs
sudo npm install -g pm2 tsx
# 2. Clone & install
git clone https://github.com/chulopp/FUD.ai.git
cd FUD.ai && npm install
# 3. Set environment variables
nano .env.local # paste your env vars
# 4. Start worker
pm2 start "npm run croo:worker:prod" --name "fud-croo-worker"
pm2 startup && pm2 save # auto-restart on reboot
# 5. Monitor
pm2 logs fud-croo-workerWarning
You must run exactly one replica of the worker per CROO SDK key. A second instance with the same key will be rejected with WebSocket close code 1008 (Policy Violation).
| Layer | Technology |
|---|---|
| Framework | Next.js 16.2.10 (App Router, Turbopack) |
| Language | TypeScript 5 |
| UI | React 19, Tailwind CSS v4, Framer Motion, Recharts, Lucide Icons |
| Docs | Fumadocs (MDX, integrated at /docs) |
| State / Cache | Upstash Redis (REST-based serverless Redis) |
| AI / Reasoning | MCTS-inspired multi-branch engine, Reflexion loop, OpenRouter / Gemini / DeepSeek |
| On-chain data | GoPlus Security, RugCheck, DexScreener, CoinGecko, DefiLlama, Bybit |
| Social signals | agent-twitter-client (native), Telegram web scraper (axios + cheerio) |
| Agent protocol | CROO CAP SDK (@croo-network/sdk), Base mainnet settlement |
| Validation | Zod 4 |
- Real-time manipulation detection — distinguishes organic fear from coordinated FUD campaigns using explicit coordination metrics
- Coordination & Sybil detection —
unique_author_ratio,duplicate_text_cluster_size(Jaccard clustering),cross_platform_burst_window_minutes - MCTS-inspired reasoning — three parallel scenarios (Real Crash / False FUD / Whale Manipulation) scored against cross-validated evidence
- Reflexion loop — learns from incorrect past predictions, auto-calibrates confidence
- Async job pattern —
202 + job_id+ polling, max pipeline time 150 seconds - 8-field structured verdict — machine-readable, directly consumable by trading bots
- Pay-per-call at $0.02 USDC — on-chain settlement via CROO CAP on Base, no subscriptions
- Agent-to-agent native — callable directly by any bot or agent with programmatic budget management
- Live demo — rate-limited showcase on the landing page
POST /api/agent
{
"coin_symbol": "ETH",
"contract_address": "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
"chain_id": "1"
}Response 202 Accepted:
{
"job_id": "550e8400-e29b-41d4-a716-446655440000",
"status": "pending",
"coin_symbol": "ETH",
"poll_url": "/api/agent/550e8400-e29b-41d4-a716-446655440000",
"message": "Analysis job accepted. Poll poll_url for results."
}GET /api/agent/{job_id}
Response 200 OK (completed):
{
"status": "completed",
"coin_symbol": "ETH",
"executable_verdict": "IGNORE_FUD",
"confidence": 0.82,
"drama_index": 61,
"chatter_level": 74,
"risk_score": 52,
"dominant_branch": "False FUD",
"branch_probabilities": {
"Real Crash": 0.18,
"False FUD": 0.67,
"Whale Manipulation": 0.15
},
"evidence_chain": [
{ "evidence": "On-chain: no unusual whale outflows in last 6h", "weight": 0.8 },
{ "evidence": "Social: 73% of negative posts share identical text (Jaccard >0.85)", "weight": 0.9 }
],
"coordination_signals": {
"unique_author_ratio": 0.12,
"duplicate_text_cluster_size": 41,
"cross_platform_burst_window_minutes": 8
},
"served_from_cache": false
}Verdict values:
| Verdict | Meaning |
|---|---|
IGNORE_FUD |
Detected as coordinated FUD — hold position |
HOLD |
Unclear signal — monitor but don't act |
ACCUMULATE |
Fear is overblown — potential buying opportunity |
LIQUIDATE_LONGS |
Genuine threat detected — reduce exposure |
INSUFFICIENT_DATA |
Not enough on-chain/social signal to conclude |
Polling strategy: Poll every 2–3 seconds. Jobs complete within 30–150 seconds depending on chain and token data availability.
FUD.ai is designed to never leave a paid order undelivered:
| Mechanism | What it does |
|---|---|
| SLA Watchdog | If the pipeline hasn't completed by 480s (80% of the 600s SLA), a pre-built degraded result is delivered automatically. The buyer always gets a response. |
| Fetch Timeout Protection | All external API calls (Bybit, CoinGecko, GoPlus, RapidAPI, LLMs) are wrapped with a configurable timeout. A hanging upstream never blocks the pipeline indefinitely. |
| LLM Cascade Fallback | If the primary LLM fails or times out, the engine automatically falls back through a pre-configured cascade (e.g., OpenRouter → Gemini). |
| Redis Concurrency Semaphore | A global pipeline counter in Redis (shared between the Vercel route and CROO worker) caps concurrent pipelines at 5 — preventing OOM on the LLM host. |
| Graceful Degradation | Any pipeline failure produces a structured degraded verdict (fallback: true, status: "degraded") rather than an unhandled error, so downstream consumers always receive a parseable response. |
| Job Expiry | Redis job records expire after 10 minutes — stale jobs from crashed workers self-clean without manual intervention. |
| Reflexion Loop | Every completed prediction is stored and evaluated against the actual price outcome. Incorrect predictions feed back into confidence calibration automatically. |
FUD.ai/
├── app/
│ ├── api/
│ │ ├── agent/route.ts # POST + GET /api/agent (async job submit + quota)
│ │ ├── agent/[job_id]/route.ts # GET /api/agent/{job_id} (poll result)
│ │ ├── cron/calibrate/route.ts # Weekly Reflexion calibration cron
│ │ └── search/route.ts # Fumadocs Orama search
│ ├── components/ # Navbar, Hero, Live Demo, Verdict display
│ ├── docs/ # Fumadocs route (/docs)
│ ├── lib/
│ │ ├── mcts/ # MCTS pipeline, dispatcher, calibration, step logger
│ │ ├── ingestion/ # 8-provider data layer (market, security, social)
│ │ ├── llm/ # LLM engine abstractions + cascade fallback
│ │ ├── redis/ # Job store, concurrency semaphore, ingestion cache
│ │ └── utils/ # CROO schema helpers, fetch-with-timeout
│ ├── page.tsx # Landing page
│ ├── layout.tsx # Root layout
│ └── globals.css # Design tokens, theme vars
├── components/
│ └── mdx.tsx # MDX components (YouTube embed, TypeTable)
├── content/docs/ # Fumadocs MDX documentation (12 pages)
├── lib/
│ ├── source.ts # Fumadocs source loader
│ └── layout.shared.tsx # Shared docs layout config
├── public/
│ └── LOGOFUD.svg # Brand logo
├── scripts/
│ └── croo-provider-worker.ts # CROO CAP worker (separate long-running process)
├── source.config.ts # Fumadocs MDX config
├── next.config.mjs # Next.js + Fumadocs MDX plugin
└── .env.example # Environment variable template
- Multi-chain support — extend GoPlus & DexScreener ingestion to Solana, Arbitrum, Polygon
- Streaming verdicts — SSE endpoint to push pipeline step updates in real-time instead of polling
- Persistent calibration dashboard — public endpoint exposing historical accuracy per confidence bucket
- Discord / Telegram integration — pre-built bot templates that call the API and format verdicts
- Webhook delivery — push completed results to a caller-provided URL instead of polling
- On-chain reputation scoring — aggregate per-wallet threat history into a persistent score
Contributions are welcome! FUD.ai is an open project — whether you're fixing a bug, adding a data provider, improving the MCTS dispatcher, or enhancing the docs.
- Fork the repository
- Create a feature branch:
git checkout -b feat/your-feature-name - Make your changes — keep commits focused and descriptive
- Test locally: run
npm run devand verify your changes work end-to-end - Open a Pull Request — describe what you changed and why
- Adding a new on-chain data provider (e.g., Nansen, Chainalysis)
- Improving the Telegram scraper to handle more post formats
- Writing additional MDX documentation pages
- Adding more test scenarios to
testsprite_tests/
- Read
AGENTS.mdbefore writing any code — it contains important Next.js-specific rules for this codebase - All Redis operations are in
app/lib/redis/— keep side effects contained there - The MCTS pipeline entry point is
app/lib/mcts/pipeline.ts:executeFudAnalysis() - LLM cascade configuration is in
app/lib/llm/engines.ts
This project is licensed under the MIT License. See the LICENSE file for details.
Autonomous crypto intelligence · Pay-per-call · Settlement on Base · Open to contributions