Last Updated: 2026
Every AI agent needs tools. A financial advisor agent needs market data. A compliance agent needs regulatory screening. A marketing bot needs audience intelligence. Until now, blockchain intelligence – one of the richest behavioral data sources in the world – has been locked behind complex APIs that require deep crypto expertise to use.
That changes with Model Context Protocol (MCP).
ChainAware has published 12 open-source, pre-built agent definitions on GitHub that give any AI agent – Claude, GPT, or custom LLM – instant access to 14 million+ wallet behavioral profiles, 98% accurate fraud prediction, real-time AML screening, token holder analysis, and more. No crypto knowledge required. No custom integration work. Just clone, configure your API key, and your agent gains blockchain superpowers.
This guide covers all 12 agents, explains the MCP architecture in plain language, shows real-world multi-agent scenarios, and walks you through integration step by step. Whether you’re building financial compliance tools, investment research systems, or growth automation, these blockchain capabilities are now one configuration file away. For a full product overview, see the ChainAware For AI Agents overview.
In This Guide
- What Is MCP? (Plain Language Explanation)
- Why MCP vs Direct API Integration
- Architecture Overview
- All 12 ChainAware MCP Agents Explained
- 3 Multi-Agent Scenarios
- Step-by-Step Integration Guide
- Use Cases by Domain
- Frequently Asked Questions
What Is MCP? (Plain Language Explanation)
MCP stands for Model Context Protocol – an open standard introduced by Anthropic in late 2024 that defines how AI agents communicate with external tools and data sources. Think of it as USB-C for AI agents: a single, universal connector that lets any compatible AI system plug into any compatible tool – without custom integration work for each pairing. Full technical documentation and tool reference at the Prediction MCP learn guide.
Before MCP, connecting an AI agent to a database or API required: writing custom function-calling code for each tool, maintaining separate API clients per service, rebuilding integrations whenever tool interfaces changed, and training agents specifically on each tool’s schema.
With MCP, tool providers (like ChainAware) publish a standardized server definition. Any MCP-compatible AI agent – Claude, GPT, open-source LLMs – can automatically discover, understand, and call that tool using natural language. The agent figures out when and how to call the tool based on the task at hand.
According to the official MCP documentation, the protocol is designed to give AI models “a standardized way to access context from tools, files, databases, and APIs.” In practice, this means your compliance agent can call a blockchain AML screening tool the same way it calls a sanctions database – without any extra integration work.
MCP vs Function Calling vs RAG
| Approach | What It Is | Best For |
|---|---|---|
| Function Calling | Hardcoded API calls per provider | Single-tool, single-agent setups |
| RAG | Retrieve documents for context | Knowledge retrieval, Q&A systems |
| MCP | Universal protocol, auto-discoverable tools | Multi-tool, multi-agent architectures |
MCP shines in multi-agent systems where different agents need to share tools, or where a single agent needs to orchestrate calls across many data sources dynamically.
Why MCP vs Direct API Integration
If ChainAware already has a REST API, why use MCP at all? The answer is about agent-native design versus developer-first design.
A traditional REST API is designed for developers: endpoints, authentication headers, JSON schemas, documentation pages. Your AI agent can call it – but you need to write wrapper code, handle errors, parse responses, and teach the agent when and why to make each call.
An MCP server is designed for agents: the capability description, input schema, and expected output are all defined in a format that LLMs natively understand. The agent reads the tool definition and autonomously decides when to invoke it based on the task context.
- Zero integration boilerplate – no API client code to write or maintain
- Autonomous tool selection – agent decides which tool to call, not your code
- Natural language invocation – “check if this wallet is safe” instead of constructing request objects
- Composable with other MCP tools – chain ChainAware calls with database queries, web searches, Slack notifications
- Works across LLM providers – same agent definition works with Claude, GPT, and open-source models
- Maintained by tool provider – when ChainAware updates its capabilities, the MCP definition updates, not your code
According to research from the Anthropic AI safety and alignment team on building effective agents, the most reliable agentic systems use well-defined tool interfaces that agents can understand and invoke without ambiguity. MCP is that interface.
Architecture Overview
Understanding how ChainAware MCP fits into an AI agent architecture helps clarify what you’re building. The flow is simple: your agent receives a task, identifies it needs blockchain intelligence, calls the appropriate ChainAware MCP tool in natural language, receives structured results, and incorporates them into its response or next action. The agent never needs to know about REST endpoints, authentication headers, or JSON schemas – MCP handles that layer.
┌─────────────────────────────────────────────────────────┐
│ Your AI Agent │
│ (Claude / GPT / Custom LLM) │
│ │
│ "Analyze this wallet before approving the transfer" │
└──────────────────────┬──────────────────────────────┘
│ MCP Protocol
▼
┌─────────────────────────────────────────────────────────┐
│ ChainAware MCP Server │
│ │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │fraud-detector│ │ aml-scorer │ │wallet-ranker │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │token-ranker │ │trust-scorer │ │whale-detector│ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
│ + 6 more agents... │
└──────────────────────┬──────────────────────────────┘
│ API calls
▼
┌─────────────────────────────────────────────────────────┐
│ ChainAware Prediction Engine │
│ │
│ 14M+ wallets · 8 blockchains · 98% accuracy │
│ ML models · Graph neural networks · Real-time data │
└─────────────────────────────────────────────────────────┘Each of the 12 agent definition files in the GitHub repository contains the tool description, capability scope, and usage examples that allow any compatible LLM to understand and invoke the capability correctly.
All 12 ChainAware MCP Agents Explained
Each agent below corresponds to a file in the /.claude/agents/ directory. The full catalogue with use case guidance is available at the Ready-Made Agents learn guide. Every agent works with MCP-compatible AI systems (Claude, GPT, custom LLMs) and requires an active ChainAware MCP subscription at chainaware.ai/mcp.
1. fraud-detector
GitHub: chainaware-fraud-detector.md
What it does: Evaluates any wallet address for fraud probability using ChainAware’s ML models trained on 14M+ wallets. Returns a trust score (0-100%), behavioral red flags, mixer interactions, network connections to known fraud addresses, and an overall fraud risk classification. This is ChainAware’s flagship capability – the engine that achieves 98% prediction accuracy by analyzing behavioral patterns rather than just blocklist matching. Full documentation at the Security & Fraud Agents learn guide.
Who needs it: Payment processors that need to screen crypto payees before releasing funds. DeFi protocol operators deciding whether to allow large withdrawals. Exchange compliance teams reviewing high-value accounts. Insurance underwriters assessing crypto custody risk. Lending platforms evaluating borrower creditworthiness in Web3.
Real-world integration example: An agent prompt like “A user wants to withdraw $85,000 from our DeFi protocol to wallet 0x4a2b…c8f1. Before approving, run a full fraud assessment and tell me if this transaction is safe to process” – the agent calls fraud-detector, receives the trust score and risk factors, and either auto-approves or flags for human review – all without the developer writing a single API call. See the complete guide: ChainAware Fraud Detector Guide.
2. rug-pull-detector
GitHub: chainaware-rug-pull-detector.md
What it does: Analyzes a token or project wallet for rug pull indicators – behaviors that signal the founders or team intend to abandon the project and exit with investor funds. Detection signals include: treasury wallet concentration, team allocation patterns, liquidity lock status, developer wallet interaction history, sudden large transfer preparation, and similarity to historical rug pull behavioral signatures.
Who needs it: Investment research agents evaluating new DeFi projects. DAO governance bots assessing partnership proposals. Token launch platforms conducting pre-listing due diligence. Institutional crypto fund managers screening emerging positions.
Real-world integration example: “A new DeFi yield protocol launched 3 weeks ago and is offering 800% APY. The contract address is 0x9c3d…f2a7. Assess the rug pull risk before we recommend it to our users.”
3. aml-scorer
GitHub: chainaware-aml-scorer.md
What it does: Runs comprehensive Anti-Money Laundering screening on a wallet address. Returns sanctions list status (OFAC SDN and equivalents), mixer/tumbler interaction history, connections to known illicit addresses, geographic risk indicators, transaction structuring patterns, and an overall AML risk score. Designed to meet regulatory requirements for VASP compliance under FATF Recommendation 16 and regional equivalents.
Who needs it: Any compliance agent operating in regulated financial environments. Banks integrating crypto payment rails. Exchanges required to file SARs. Fintech platforms offering crypto on/off ramps. See our complete Blockchain Compliance Guide for regulatory context.
Real-world integration example: “New corporate client wants to pay our invoice in USDC from wallet 0x7b1e…d4c9. Run a full AML check and tell me if we can legally accept this payment without filing a SAR.”
4. wallet-ranker
GitHub: chainaware-wallet-ranker.md
What it does: Generates a comprehensive Wallet Rank score (0-100) for any address, consolidating 10 behavioral parameters: risk willingness, experience level, risk capability, predicted trust, intentions, transaction categories, protocol diversity, AML status, wallet age, and balance. Full methodology: ChainAware Wallet Rank Guide.
Who needs it: Growth agents prioritizing user acquisition spend. Token distribution systems that reward high-quality users. DAO governance systems weighting voting power by wallet quality. Lending protocols adjusting credit limits by wallet sophistication.
5. token-ranker
GitHub: chainaware-token-ranker.md
What it does: Assesses the quality of a token’s holder base using ChainAware’s behavioral intelligence. Instead of measuring price or market cap, Token Rank measures who holds the token – the average Wallet Rank of holders, distribution concentration, holder experience levels, and ratio of genuine long-term holders vs farmers and bots. Full explanation: What Is Token Rank?
Who needs it: Investment research agents evaluating token fundamentals beyond price. Listing committees assessing project quality for exchange or launchpad inclusion. Institutional fund managers conducting due diligence.
6. reputation-scorer
GitHub: chainaware-reputation-scorer.md
What it does: Builds a holistic on-chain reputation profile for a wallet – synthesizing transaction history quality, protocol interaction integrity, community participation, governance behavior, and behavioral consistency over time. Unlike trust score (which focuses on fraud risk) or wallet rank (which measures overall quality), reputation score captures community standing.
Who needs it: DAO governance agents evaluating voting eligibility and weight. Marketplace platforms assessing seller trustworthiness. Peer-to-peer lending agents evaluating borrower reliability without credit bureaus.
7. trust-scorer
GitHub: chainaware-trust-scorer.md
What it does: Returns a focused trust probability score (0-100%) representing the likelihood that a wallet will behave legitimately in future transactions. Trust score is forward-looking (predicts future behavior) whereas fraud detection is risk-weighted (assesses current risk level). Useful for tiered access decisions: high trust → full access, medium trust → enhanced monitoring, low trust → additional verification required.
Who needs it: Access control agents managing feature gating in DeFi platforms. KYC-lite systems that use behavioral trust as a supplement to identity verification. Risk management systems setting leverage limits based on behavioral trust.
8. analyst
What it does: A general-purpose blockchain intelligence agent that synthesizes multiple ChainAware data points into comprehensive analytical reports. Instead of returning raw scores, the analyst interprets and contextualizes behavioral data – writing narrative summaries, identifying patterns, comparing against benchmarks, and highlighting actionable insights.
Who needs it: Research report generation pipelines delivering insights to investors or executives. Compliance reporting agents generating regulatory documentation. Due diligence automation tools that need readable summaries, not just numbers.
9. token-analyzer
GitHub: chainaware-token-analyzer.md
What it does: Deep-dives into a specific token – analyzing its smart contract interactions, holder distribution, whale concentration, trading pattern quality (genuine vs wash trading), liquidity depth and health, and on-chain growth metrics. Goes beyond surface-level market cap and volume to assess whether a token has genuine ecosystem traction or manufactured metrics.
10. whale-detector
GitHub: chainaware-whale-detector.md
What it does: Identifies, profiles, and monitors high-value wallet addresses (“whales”) – wallets with significant portfolio value and market influence. Returns whale classification, portfolio composition, recent large movement signals, historical behavior during market events, and behavioral predictions for likely near-term actions.
11. wallet-marketer
GitHub: chainaware-wallet-marketer.md
What it does: Generates personalized marketing and engagement strategies for a specific wallet based on its behavioral profile. Analyzes experience level, risk tolerance, protocol preferences, and predicted intentions to recommend the right messaging tone, which product features to highlight, optimal communication timing, and appropriate incentive structures.
12. onboarding-router
GitHub: chainaware-onboarding-router.md
What it does: Instantly classifies a newly connecting wallet and routes it to the appropriate onboarding experience based on behavioral profile. Determines experience level (1-5), risk tolerance, primary activity focus (DeFi, NFT, gaming, trading), and predicted product fit – then recommends the specific onboarding path, feature exposure sequence, support level, and educational content appropriate for that wallet.
3 Multi-Agent Scenarios
The real power of MCP emerges when multiple agents collaborate – each calling different ChainAware capabilities to accomplish complex tasks that no single agent could handle alone. Here are three production-ready architectures.
Scenario 1: Investment Research Pipeline
A crypto fund’s AI research system needs to evaluate 50 new DeFi protocols per week and deliver investment recommendations to the investment committee. The pipeline involves three coordinating agents:
Agent A – Initial Screening (calls rug-pull-detector + token-ranker): Scans every new protocol automatically. Filters out rug pull risks and low-quality token communities in the first pass. Reduces 50 protocols to 15 worth deeper analysis.
Agent B – Deep Analysis (calls token-analyzer + whale-detector + wallet-ranker): For each surviving protocol, runs full token analysis, identifies whale concentration risk, and assesses the quality of the top 100 holders.
Agent C – Report Generation (calls analyst): Synthesizes all data into investment committee-ready memos with narrative summaries, risk assessments, and buy/watch/pass recommendations.
Scenario 2: Real-Time Compliance Agent
A regulated crypto exchange needs to screen every withdrawal request in real-time without slowing down the user experience. Three compliance agents run in parallel:
Fast Path Agent (calls trust-scorer): Instant trust check runs in <100ms. For high-trust wallets (score 85+), auto-approves withdrawal. Handles 70% of requests without further review.
Standard Review Agent (calls aml-scorer + fraud-detector): For medium-trust wallets (score 50-85), runs full AML and fraud screen. Auto-approves if both pass, escalates if either flags risk.
Enhanced Review Agent (calls analyst + reputation-scorer): For low-trust wallets, generates a full compliance report and reputation assessment that human compliance officers review before decision.
Scenario 3: Growth and Marketing Automation
A DeFi protocol’s growth team uses AI agents to run the entire user acquisition and retention lifecycle without manual segmentation work:
Acquisition Agent (calls wallet-ranker): Scores inbound users from each marketing channel in real-time. Reports Wallet Rank distribution per channel, enabling budget reallocation toward channels that deliver high-quality users (Rank 70+) instead of airdrop farmers (Rank <30).
Onboarding Agent (calls onboarding-router): Instantly routes each connecting wallet to the right first experience – expert users get the pro dashboard immediately, newcomers get guided tutorials, and high-fraud-risk wallets get additional verification before access. Completion rates increase from 35% to 62%.
Retention Agent (calls wallet-marketer + whale-detector): Monitors all active users for churn signals and whale exit preparation. Automatically triggers personalized retention campaigns for at-risk power users.
Step-by-Step Integration Guide
Getting started with ChainAware MCP takes under 30 minutes for a working integration. For additional setup guidance, see the Prediction MCP learn guide. Here’s the complete path from zero to production.
Step 1: Get Your MCP API Key
Visit chainaware.ai/mcp and select a subscription plan. All plans provide access to the full MCP server with all 12 agent capabilities. The API key grants authenticated access to ChainAware’s prediction engine for your MCP requests.
Step 2: Clone the GitHub Repository
git clone https://github.com/ChainAware/behavioral-prediction-mcp.git
cd behavioral-prediction-mcpStep 3: Configure Your API Key
# Set your ChainAware API key as an environment variable
export CHAINAWARE_API_KEY="your_api_key_here"
# Or add to your .env file
echo "CHAINAWARE_API_KEY=your_api_key_here" >> .envStep 4: Configure Your MCP Client
{
"mcpServers": {
"chainaware": {
"command": "node",
"args": ["path/to/behavioral-prediction-mcp/server.js"],
"env": {
"CHAINAWARE_API_KEY": "your_api_key_here"
}
}
}
}Step 5: Select the Agents You Need
Copy the relevant agent definition files from .claude/agents/ to your project. Each file is independent – you don’t need all 12. A compliance-focused deployment might only need aml-scorer, fraud-detector, and trust-scorer. A growth platform might only need wallet-ranker, onboarding-router, and wallet-marketer.
Step 6: Test with Natural Language
Once configured, test your integration by asking your agent natural language questions: “Check if wallet 0x1234…5678 is safe to transact with”, “What’s the fraud risk on this address?”, “Give me the Wallet Rank for 0xabcd…ef01”, “Is this token’s volume genuine or wash-traded?”, “Should we onboard this new user to beginner or expert flow?”
Use Cases by Domain
ChainAware MCP agents aren’t just for crypto companies. Any AI system that handles financial relationships, identity verification, or community management can benefit from blockchain behavioral intelligence.
Financial Services & FinTech
- Payment processors:
fraud-detector+aml-scorerfor every crypto payment acceptance - Neo-banks with crypto rails:
trust-scorerfor tiered feature access without full KYC - Crypto lending platforms:
wallet-ranker+reputation-scorerfor creditworthiness assessment - Insurance underwriters:
analystfor crypto custody risk reports
Institutional Investment
- Crypto funds: Full pipeline using
rug-pull-detector→token-ranker→token-analyzer→analyst - Trading desks:
whale-detectorfor large holder movement signals - Research platforms:
token-analyzerfor data-driven token assessments
DeFi & Web3 Products
- DEXs and lending protocols:
fraud-detector+trust-scorerfor real-time transaction screening - NFT marketplaces:
reputation-scorerfor seller trust,whale-detectorfor high-value buyer identification - DAOs:
reputation-scorer+wallet-rankerfor governance weight calibration - Launchpads:
rug-pull-detector+token-analyzerfor project screening
Marketing & Growth
- Web3 marketing platforms:
wallet-marketerfor personalized campaign generation - CRM systems:
wallet-rankerfor behavioral segmentation without PII - Growth automation tools:
onboarding-routerfor intelligent user flow selection - Token distribution platforms:
wallet-rankerfor anti-sybil, quality-weighted distributions
Frequently Asked Questions
Do I need to know blockchain or crypto to use these agents?
No. The entire point of MCP is abstraction – your AI agent understands and calls the tools in natural language. You describe what you want (“check if this wallet is trustworthy”) and ChainAware’s MCP server handles all the blockchain-specific complexity. You need a ChainAware API key and the agent definition files. No crypto expertise required.
Which AI systems are compatible with ChainAware MCP?
Any MCP-compatible system, including Claude (all versions), GPT-4 and later (via MCP bridges), open-source models running in MCP-compatible frameworks, LangChain agents, AutoGen multi-agent systems, and custom LLM pipelines. See the MCP documentation for framework-specific setup.
What data does ChainAware analyze and how accurate is it?
ChainAware analyzes 14M+ wallet addresses across 8 blockchains (Ethereum, BNB Smart Chain, Polygon, Base, Solana, Avalanche, Arbitrum, Haqq Network). All data is derived from public on-chain transaction history – no personal information is collected or required. Fraud prediction accuracy is 98%, measured as F1 score on held-out test data. Inference latency is <100ms for real-time applications.
Is the GitHub repository open source? Can I modify the agents?
Yes. The agent definition files in the behavioral-prediction-mcp GitHub repository are open source. You can fork the repo, modify agent descriptions, adjust behavior, and create custom agent definitions that call ChainAware’s underlying capabilities in new ways. The MCP subscription covers API access; the agent definitions themselves are free to use and modify.
Conclusion
The emergence of MCP as an open standard for AI agent tool integration marks a fundamental shift in how blockchain intelligence gets deployed. With ChainAware’s 12 pre-built MCP agents, any AI agent – compliance bot, investment research system, growth automation platform, due diligence pipeline – can now call upon 14 million wallet behavioral profiles, 98% accurate fraud prediction, real-time AML screening, and comprehensive token analysis in natural language.
Clone the repo. Get your API key. Give your agent blockchain superpowers.