# ChainAware Behavioural Prediction MCP Server (remote · prediction.mcp.chainaware.ai)

AI-powered tools to analyze wallet behaviour prediction, fraud detection and rug pull prediction.

- Trust score: 49/100 (low)
- Change this week: +23
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-03

## Components

- remote · `prediction.mcp.chainaware.ai`: 49/100 (this document), [markdown](https://verifymcp.io/servers/chainaware-chainaware-behavioral-prediction-mcp/prediction.md), [page](https://verifymcp.io/servers/chainaware-chainaware-behavioral-prediction-mcp/prediction)

## Channel facts

- Endpoint: `https://prediction.mcp.chainaware.ai/sse`
- Transports: `sse`
- Auth: `required`
- Version: `1.0.0`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-03.

- **Endpoint Security**: 57/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation not fully verified: no authorisation is required to call this server, and 14 tool(s) never declared a destructiveHint. The MCP spec treats an absent hint as destructive by default, so we cannot call this surface safe.
  - HTTPS is enforced; there's no plaintext access path.
  - HSTS check failed: the Strict-Transport-Security header is absent.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 40/100
  - Verified sse transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 40/100
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 9715 tokens (~693/item across 14 items; 14 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 27/100
  - Stability observed for 8 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 71/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 0% of tool parameters carry a description.
  - Structured output schemas are declared (71% of tools); any adoption earns full credit.
- **Capabilities**: 60/100
  - Spec-recency check failed: implements MCP spec 2025-06-18; the latest is 2026-07-28.

## Install

### Claude

```bash
claude mcp add --transport http chainaware-chainaware-behavioral-prediction-mcp https://prediction.mcp.chainaware.ai/sse
```

### Codex

```toml
[mcp_servers.chainaware-chainaware-behavioral-prediction-mcp]
url = "https://prediction.mcp.chainaware.ai/sse"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "chainaware-chainaware-behavioral-prediction-mcp": {
      "type": "remote",
      "url": "https://prediction.mcp.chainaware.ai/sse",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add chainaware-chainaware-behavioral-prediction-mcp --url https://prediction.mcp.chainaware.ai/sse --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  chainaware-chainaware-behavioral-prediction-mcp:
    url: "https://prediction.mcp.chainaware.ai/sse"
```

### Other

```json
{
  "mcpServers": {
    "chainaware-chainaware-behavioral-prediction-mcp": {
      "type": "http",
      "url": "https://prediction.mcp.chainaware.ai/sse"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-03 (score 49, +1)

No change was recorded against any check on this day. Stability & Change Management went from 23 to 27. That category is still filling its 30-day observation window: 7 days of observed history at the previous scan, 8 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-08-01 (score 48, +16)

- [security] Authorization: Authorisation not fully verified: no authorisation is required to call this server, and 14 tool(s) never declared a destructiveHint. The MCP spec treats an absent hint as destructive by default, so we cannot call this surface safe.
- [functional regression] Schema quality: unverified → fail
- [functional regression] Schema quality: unverified → fail
- [functional improvement] Schema quality: unverified → good
- [functional improvement] Tool coverage: unverified → 100
- [functional] New tool “token_rank_single”
- [functional] New tool “token_rank_list”
- [functional] New tool “run_token_audit”
- [functional] New tool “predictive_rug_pull”
- [functional] New tool “predictive_fraud_batch”
- [functional] New tool “predictive_fraud”
- [functional] New tool “predictive_behaviour_batch”
- [functional] New tool “predictive_behaviour”
- [functional] New tool “get_token_audit_result”
- [functional] New tool “get_job_results”
- [functional] New tool “credit_score”
- [functional] New tool “check_job_status”
- [functional] New tool “agents_trust_score_single”
- [functional] New tool “agents_trust_score_list”

### 2026-07-31 (score 32, −13)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-30 (score 45, −3)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-29 (score 48, +1)

No change was recorded against any check on this day. Stability & Change Management went from 7 to 10. That category is still filling its 30-day observation window: 2 days of observed history at the previous scan, 3 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-07-28 (score 47, +21)

- [security] Authorization: Authorisation not fully verified: no authorisation is required to call this server, and 14 tool(s) never declared a destructiveHint. The MCP spec treats an absent hint as destructive by default, so we cannot call this surface safe.
- [functional regression] Schema quality: unverified → fail
- [functional regression] Schema quality: unverified → fail
- [functional improvement] Schema quality: unverified → good
- [functional improvement] Tool coverage: unverified → 100
- [functional] First check of Tool coverage: 71
- [functional] First check of Tool coverage: 0
- [functional] New tool “token_rank_single”
- [functional] New tool “token_rank_list”
- [functional] New tool “run_token_audit”
- [functional] New tool “predictive_rug_pull”
- [functional] New tool “predictive_fraud_batch”
- [functional] New tool “predictive_fraud”
- [functional] New tool “predictive_behaviour_batch”
- [functional] New tool “predictive_behaviour”
- [functional] New tool “get_token_audit_result”
- [functional] New tool “get_job_results”
- [functional] New tool “credit_score”
- [functional] New tool “check_job_status”
- [functional] New tool “agents_trust_score_single”
- [functional] New tool “agents_trust_score_list”

### 2026-07-27 (score 26, +1)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-26 (score 25)

First indexed and scored.

## MCP tools (14)

### `predictive_fraud` (~1025 tokens)

🔮 Predictive Fraud Detection Tool

    This AI‑powered algorithm forecasts the likelihood of fraudulent activity
    on a given wallet address *before* it happens (≈98% accuracy), and performs
    AML/Anti‑Money‑Laundering checks. Use this when your user wants a risk
    assessment or early‑warning on a blockchain address.

    ———
    📥 Input Arguments:
      • apiKey (string, required): API key for authentication.
      • network (string, required): Blockchain network identifier (e.g. ETH for Ethereum, BNB for Binance, POLYGON for Polygon,TON for Telegram(TON), BASE for Base, HAQQ for Haqq)
      • walletAddress (string, required): The wallet address to evaluate.

    ➡️ Use Cases:
      • What is the fraudulent status of this address ?
      • “Is my new wallet at risk of being used for fraud?”  
      • “Monitor a high‑value address for suspicious future activity.”  

    ———
    📤 Expected Output (JSON):
    ```json
    {
      "message": "string",                         // e.g. “Success” or error description
      "walletAddress": "string",                   // blockchain wallet address that was analyzed
      "chain": "string",                           // blockchain network identifier (e.g. ETH, BNB,POLYGON,TON,BASE, TRON, HAQQ)
      "status": "string",                          // classification result (e.g. “Fraud” | “Not Fraud” | “New Address”)
      "probabilityFraud": "0.00–1.00",             // decimal fraud probability score (string to preserve precision)
      
      "token": "string | null",                    // optional token associated with the check (may be null)
      "lastChecked": "ISO-8601 timestamp",         // last time the wallet risk analysis was executed
      
      "forensic_details": {
        "cybercrime": "string",                    // indicator score for cybercrime activity
        "money_laundering": "string",              // indicator score for money laundering activity
        "number_of_malicious_contracts_created":…

Input parameters:

- `apiKey` (string, required)
- `network` (string, required)
- `walletAddress` (string, required)

### `predictive_fraud_batch` (~207 tokens)

Schedule a batch fraud calculation job for a list of wallet addresses.
    Use this when the user provides a CSV or list of addresses to analyse.
    Returns a job_id and signature immediately — report the job_id to the user and 
    store both job_id and signature in context, they are required for all follow-up calls.
    Do NOT poll or wait for results after scheduling.

    Args:
        apiKey: API key for authentication.
        addresses: List of wallet objects, each with walletAddress and optionally network 
                  e.g. [{"walletAddress": "0x123", "network": "ETH"}] max 1000
        network: Blockchain network identifier (e.g. ETH for Ethereum, BNB for Binance, 
                POLYGON for Polygon, TON for Telegram(TON), BASE for Base, HAQQ for Haqq)

Input parameters:

- `addresses` (array, required)
- `apiKey` (string, required)
- `network` (string, required)

### `predictive_behaviour` (~1603 tokens)

🔍 Predictive Behaviour Analysis Tool

    This AI‑driven engine projects what a wallet address intentions or what address is likely to do next,
    profiles its past on‑chain history, and recommends personalized actions.
    Use this when you need:
      • Next‑best‑action predictions and intentions(“Will this address deposit, trade, or stake?”)  
      • A risk‑tolerance and experience profile  
      • Category segmentation (e.g. NFT, DeFi, Bridge usage)  
      • Custom recommendations based on historical patterns

    📥 Input Arguments:
      • apiKey        — (string, required) API key for authentication. 
      • network       — (string, required) Blockchain network (e.g. ETH for Ethereum, BNB for Binance, BASE for Base, HAQQ for Haqq)
      • walletAddress — (string, required) The wallet or contract address to analyze  

    ➡️ Example Use Cases:
      – “What will this address do next?”  
      – “Is the user high‑risk or experienced?”  
      – “Recommend the best DeFi strategies for this address.”

    ———
    📤 Expected Output Schema (JSON):
    ```
    {
      "message": "string",                           // e.g. “Success” or error description
      "walletAddress": "string",                     // blockchain wallet address analyzed
      "status": "string",                            // fraud classification result (e.g. “Fraud” | “Not Fraud” | “New Address”)

      "probabilityFraud": "0.00–1.00",               // decimal probability score indicating fraud risk
      "token": "string | null",                      // optional token context for the analysis
      "chain": "string",                             // blockchain network identifier (e.g. ETH, BNB,BASE,HAQQ,SOLANA)

      "lastChecked": "ISO-8601 timestamp",           // last time the wallet was analyzed

      "forensic_details": {
        "cybercrime": "string",                      // indicator of cybercrime association
        "money_laundering": "string",                // money l…

Input parameters:

- `apiKey` (string, required)
- `network` (string, required)
- `walletAddress` (string, required)

### `predictive_behaviour_batch` (~199 tokens)

Schedule a batch audit (behavioral prediction) calculation job for a list of wallet addresses.
    Use this when the user provides a CSV or list of addresses to analyse.
    Returns a job_id and signature immediately — report the job_id to the user and 
    store both job_id and signature in context, they are required for all follow-up calls.
    Do NOT poll or wait for results after scheduling.

    Args:
        apiKey: API key for authentication.
        addresses: List of wallet objects, each with walletAddress and optionally network 
                  e.g. [{"walletAddress": "0x123", "network": "ETH"}] max 1000
        network: Blockchain network identifier (e.g. ETH for Ethereum, BNB for Binance, BASE for Base, HAQQ for Haqq)

Input parameters:

- `addresses` (array, required)
- `apiKey` (string, required)
- `network` (string, required)

### `predictive_rug_pull` (~1307 tokens)

🪂 Predictive Rug‑Pull Detection Tool

    This AI‑powered engine forecasts which liquidity pools or contracts
    are likely to perform a “rug pull” in the future. Use this when you
    need to warn users before they deposit into risky pools or to monitor
    smart‑contract security on-chain.

    ———
    📥 Input Arguments:
      • apiKey        — (string, required) API key for authentication. 
      • network       — (string, required) (e.g. ETH for Ethereum, BNB for Binance, BASE for Base, HAQQ for Haqq) 
      • walletAddress — (string, required) The smart‑contract or pool address to evaluate  

    ➡️ Example Use Cases:
      – “Will this new DeFi pool rug‑pull if I stake my assets?”  
      – “Monitor my LP position for potential future exploits.”  

    ———
    📤 Expected Output Schema (JSON):
    ```
    {
      "message": "string",                         // e.g. “Success” or error description

      "contractAddress": "string",                 // smart contract address analyzed
      "pairAddress": "string",                     // liquidity pair address on DEX
      "contractCreatorAddress": "string | null",   // creator address of the contract if known

      "risk_score": 0,                             // numeric internal risk score
      "risk_status": "string",                     // qualitative risk level (e.g. “Low Risk”, “Medium Risk”, “High Risk”)

      "risk_indicators": {
        "is_honeypot": 0,                          // honeypot detection flag
        "honeypot_with_same_creator": 0,           // creator deployed previous honeypots
        "can_take_back_ownership": 0,              // contract allows reclaiming ownership
        "is_mintable": 0,                          // token supply can be minted
        "hidden_owner": 0,                         // hidden ownership mechanism detected

        "buy_tax": 0,                              // buy transaction tax percentage
        "sell_tax": 0,                             // sell t…

Input parameters:

- `apiKey` (string, required)
- `network` (string, required)
- `walletAddress` (string, required)

### `credit_score` (~386 tokens)

🔮 Credit Score Tool

    AI-driven blockchain analytics evaluate the crypto trust score for each account by reviewing inflows and outflows from Ethereum accounts alongside other blockchain data. 
    Credit Scoring tool combines AI, analytics, crypto fraud scores, and social graph analysis to assess borrower reliability comprehensively.
    Crypto Credit Score allows lenders to accurately differentiate between reliable and less trustworthy borrowers.
    This assessment is further enhanced with our predictive_fraud too and social graph analysis, providing a thorough evaluation of borrower reliability. 

    ———
    📥 Input Arguments:
      • apiKey (string, required): API key for authentication.
      • network (string, required): Blockchain network identifier (e.g. ETH for Ethereum, BNB for Binance, POLYGON for Polygon,TON for Telegram(TON), BASE for Base, HAQQ for Haqq)
      • walletAddress (string, required): The wallet address to evaluate.

    ➡️ Use Cases:
      • “What is the credit score for this wallet? ”
      • “What's calculated trust score for this wallet? ”
      • “Calculate credit score for this wallet? ”  

    ———
    📤 Expected Output (JSON):
    ```json
    {
        "message": "Success",
        "creditData": {
            "riskRating": 1,  //1-9 crypto trust score (credit score)
            "walletAddress": "" //Wallet Address which was evaluated
        }
    }
    ```
    ———
    Error cases:
      • `401 Unauthorized` → invalid `apiKey`  
      • `400 Bad Request` → malformed `network` or `walletAddress`  
      • `500 Internal Server Error` → temporary downstream failure

Input parameters:

- `apiKey` (string, required)
- `network` (string, required)
- `walletAddress` (string, required)

### `token_rank_list` (~708 tokens)

🪂 Token Rank List Tool

    TokenRank analyzes the community of token holders and ranks every token by the strength of its holders. The stronger the token holders, the stronger the token! 
    Use this when you need to know token rank of a token or tokens or compare between different categories and chains.
    You can use search,filter and sort and pagination which returns a list of tokens.

    ———
    📥 Input Arguments:
      • limit            — (string, required) Number of items ot fetch during pagination
      • offset           — (string, required) Page number(offset) during pagination
      • network          — (string, optional) The network or the chain to filter (e.g. ETH for Ethereum, BNB for Binance, BASE for Base, SOLANA for solana) 
      • sort_by           — (string, optional) Sort the returnet tokens based on e.g.: 'communityRank'  
      • sort_order        — (string,optional but required if sort_by) 'ASC' or 'DESC' sorting the value of sort_by
      • category         — (string, optional) Filter based on category of the token (e.g. 'AI Token','RWA Token','DeFi Token','DeFAI Token','DePIN Token')  
      • contract_name     — (string, optional) Search based on contract name


    ➡️ Example Use Cases:
      – “Which is the best token on AI Token category?”  
      – “Compare x token in ETH chain and BNB chain?”

    ———
    📤 Expected Output Schema (JSON):
    {
      "message": "string",                    // e.g. “Successfully fetched records” or error description
      "data": {
        "total": 0,                           // integer — total number of matching contracts
        "contracts": [
          {
            "contractAddress": "string",       // unique contract or mint address (chain-specific format)
            "contractName": "string",          // human-readable token name
            "ticker": "string",                // token symbol (usually uppercase, but not guaranteed)
            "chain": "string",                 // blo…

Input parameters:

- `category` (string, required)
- `contract_name` (string, required)
- `limit` (string, required)
- `network` (string, required)
- `offset` (string, required)
- `sort_by` (string, required)
- `sort_order` (string, required)

### `token_rank_single` (~708 tokens)

🪂 Token Rank Single Tool

    Similar to TokenRank List,Token Rank analyzes the community of token holders and ranks every token by the strength of its holders.
    Except the token rank and token details the token rank single tool fetches the best holders their details and its globalRank alongside others in same network.
    Use this when you need to know token rank of a single token based on contract address and exeact chain or network or when you need best holders of specific token in specifc network or chain

    ———
    📥 Input Arguments:
      • contract_address  — (string, required) The contract address of the token to evaluate
      • network            — (string, optional) The network or the chain to filter (e.g. ETH for Ethereum, BNB for Binance, BASE for Base, SOLANA for solana) 

    ➡️ Example Use Cases:
      – “What is the token rank for token in ETH network?”  
      – "Which are the best holders of this contract token address?”
      – “What is the token rank and its best holders?”

    ———
    📤 Expected Output Schema (JSON):
    {
      "message": "string",                      // e.g. “Successfully fetched records” or error description
      "data": {
        "contract": {
            "contractAddress": "string",       // unique contract or mint address (chain-specific format)
            "contractName": "string",          // human-readable token name
            "ticker": "string",                // token symbol (usually uppercase, but not guaranteed)
            "chain": "string",                 // blockchain network (e.g. SOLANA | ETH | BNB | BASE)
            "category": "string",              // primary category label (e.g. 'AI Token','RWA Token','DeFi Token','DeFAI Token','DePIN Token') 
            "type": "string",                  // asset classification (e.g. “token” | “nft”)
            "communityRank": 0,                // integer — raw ranking based on community metrics
            "normalizedRank": 0,               // inte…

Input parameters:

- `contract_address` (string, required)
- `network` (string, required)

### `run_token_audit` (~562 tokens)

🚀 Run Token Audit

    Requests a Token Audit for a given token contract or returns already calculated audit data for requested token. This tool is "get-or-create":
    it first checks if a completed audit already exists for this contract, and if so
    returns the FULL risk report immediately. If no audit exists yet, it queues a new
    one and returns a job_id + "queued" status instead.

    Use this tool whenever a user asks to audit, scan, check, or evaluate a token/contract
    for risk, scam signals, honeypot behavior, ownership risk, or liquidity risk. This should
    be the FIRST and ONLY tool called for a new request — do not call get_token_audit_result
    first "just to check."

    ———
    📥 Input Arguments:
      • contract_address  — (string, required) The contract address of the token to audit
      • network           — (string, required) The network/chain the token lives on (e.g. 'arbitrum', 'avalanche', 'base', 'bsc', 'eth', 'optimism', 'polygon')

    ———
    📤 Response — TWO possible shapes, check which one you got:

      A) Cached / already audited → audit_status = "complete"
        Full risk report is returned immediately (same schema as get_token_audit_result).
        Answer the user's question directly from this data. No further tool calls needed.

      B) Not yet audited → no honeypot_analysis field, instead:
        {
          "contract_address": "string",
          "chain": "string",
          "job_id": "string",
          "status": "queued",
          "message": "string"   // includes poll instructions
        }
        In this case, follow up by calling get_token_audit_result with the same
        chain + contract_address, polling every ~3-5 seconds until audit_status = "complete".

    ———
    ➡️ Example Use Cases:
      – "Audit this token contract for me: 0x..."
      – "Is this BSC token safe? 0x..."
      – "Run a risk scan on this contract before I buy"
      – "Check if this address is a honeypot"

    ———
    ⚠️ Not…

Input parameters:

- `contract_address` (string, required)
- `network` (string, required)

### `get_token_audit_result` (~1386 tokens)

🪂 Get Token Audit Result

    Fetches the current status or final results of a previously triggered Token Audit job for a given contract address and chain. 
    This is the SECOND step of the audit workflow, used to poll for and retrieve the full risk report after "Run Token Audit" has been called.
    Call this tool immediately after "Run Token Audit" to check progress, and repeatedly (poll) until the response's audit_status field equals "complete". 
    While audit_status is anything else (e.g. "queued", "running", "pending"), treat the result as not-yet-ready: do not summarize partial/empty module data to the user, just report that the audit is still in progress (optionally showing elapsed time if available) and poll again shortly.
    Once audit_status = "complete", this tool returns a full multi-module risk report — covering ownership control, liquidity health, supply/mint risk, transfer integrity, approve/permit safety, reentrancy, honeypot behavior, and an aggregated 0-100 risk score with verdict. Use this data to directly answer the user's question about token safety, risk factors, or red flags — do not fetch or re-trigger a new audit if a completed result already exists for this contract.

    ———
    📥 Input Arguments:
      • contract_address  — (string, required) The contract address of the token to evaluate
      • network           — (string, required) The network/chain the token lives on (e.g. 'arbitrum', 'avalanche', 'base', 'bsc', 'eth', 'optimism', 'polygon')


    ➡️ Example Use Cases:
      – "Is my audit for this token ready yet?"
      – "What's the risk score and verdict for this contract?"
      – "Who owns this token, can they mint or blacklist?"
      – "Is this a honeypot? What are the flags?"
      – "Give me the full breakdown of this contract's liquidity and ownership risk"

    ———
    📤 Expected Output Schema (JSON):
    {
      "contract_address": "string",
      "chain": "string",
      "audit_status": "string",
      "toke…

Input parameters:

- `contract_address` (string, required)
- `network` (string, required)

### `agents_trust_score_list` (~614 tokens)

🪂 Agent Trust Score List Tool

    The ChainAware Agent Trust Score is a 0-1000 score that measures how safe it is to interact with any ERC-8004 registered AI agent.
    Unlike voting-based reputation systems - where agents can upvote each other to manufacture trust - the Agent Trust Score is derived entirely from on-chain behavioral history. It cannot be earned in hours. It cannot be faked with a cluster of fresh wallets. It reflects the real-world track record of the human or entity controlling the agent.
    As agentic commerce scales - with AI agents autonomously completing purchases on behalf of consumers across ChatGPT, Google Gemini, and Shopify - the question of which agents can be trusted to transact is no longer theoretical. ChainAware answers it with on-chain evidence, not peer endorsements.
    It returns a list of Agents and their result.

    ———
    📥 Input Arguments:
      • page              — (string, required) Page number(page) during pagination
      • limit             — (string, required) Number of items ot fetch during pagination
      • sort_by           — (string, optional) Sort the returned agents based on e.g.: 'registered_at'  
      • sort_order        — (string, optional but required if sort_by) 'asc' or 'desc' sorting the value of sort_by (default desc)
      • registered_after  — (string, optional) Filter based on datetime when the Agent was registered.


    ➡️ Example Use Cases:
      – Give me a list of Agents and their trust score?”
      – “Which is the best Agent registered after 2025-01-01?”  

    ———
    📤 Expected Output Schema (JSON):
    {
    "total": "integer",
    "page": 1,
    "limit": 2,
    "results": [
        {
            "chain_id": "integer",
            "agent_id": "integer",
            "owner_address": "string",
            "agent_wallet": "string",
            "agent_uri": "string",
            "meta_name": "string",
            "registered_at": "ISO-8601",
            "reputation_score": "integer"…

Input parameters:

- `limit` (integer)
- `page` (integer)
- `registered_after` (string)
- `sort_by` (string)
- `sort_order` (string)

### `agents_trust_score_single` (~658 tokens)

🪂 Agent Trust Score Single Tool

    Similar to Agent Trust List, Agent Trust Score Single is a 0-1000 score that measures how safe it is to interact with any ERC-8004 registered AI agent.
    Unlike voting-based reputation systems - where agents can upvote each other to manufacture trust - the Agent Trust Score is derived entirely from on-chain behavioral history. It cannot be earned in hours. It cannot be faked with a cluster of fresh wallets. It reflects the real-world track record of the human or entity controlling the agent.
    As agentic commerce scales - with AI agents autonomously completing purchases on behalf of consumers across ChatGPT, Google Gemini, and Shopify - the question of which agents can be trusted to transact is no longer theoretical. ChainAware answers it with on-chain evidence, not peer endorsements.
    It returns the single details in depth for a requested Agent.

    ———
    📥 Input Arguments:
      • agent_id          — (integer, required) Agent id returned from agents_trust_score_list Tool
      • chain_id          — (integer, required) Chain id where Agent is deployed/registred previously fetched from agents_trust_score_list Tool

    ➡️ Example Use Cases:
      – "What is the trust score for this agent id 12314 on chain_id 56?”
    ———
    📤 Expected Output Schema (JSON):
    {
      "agent_id": "integer",
      "chain": "string",
      "chain_id": "integer",
      "owner_address": "string",
      "agent_wallet": "string",
      "wallet_verified": "boolean",
      "agent_uri": "string",
      "registered_at": "ISO-8601",
      "fetched_at": "ISO-8601",
      "error": "string",
      "meta_name": "string",
      "meta_description": "string",
      "meta_image": "string",
      "metadata_json": {
          "type": "string",
          "name": "string",
          "description": "string",
          "image": "string",
          "active": "boolean",
          "supportedTrust": "array[string]"
      },
      "registration": {…

Input parameters:

- `agent_id` (integer, required)
- `chain_id` (integer, required)

### `check_job_status` (~168 tokens)

Check the progress of a scheduled batch calculation job.
    Returns counts only (completed, failed, pending) — no wallet data.
    Call this when the user asks whether a job is done or how it is progressing.
    If status is 'processing' or 'pending', inform the user and do not call get_job_results.
    Only suggest fetching results when status is 'completed' or 'partial'.
    Both job_id and signature from schedule_calculation are required to call this tool.
    Never call this without both values present in context.
    
    Args:
        job_id: The job ID returned by schedule_calculation.
        signature: The signature returned by schedule_calculation. Required for access.

Input parameters:

- `job_id` (string, required)
- `signature` (string, required)

### `get_job_results` (~184 tokens)

Retrieve the results of a completed or partially completed batch job.
    Only call this when check_job_status shows status is 'completed' or 'partial'.
    Returns a list of completed wallet addresses and the shared chain/network — 
    use these to query the main backend for actual wallet analysis data.
    This does NOT return wallet data directly, only the address list needed to fetch it.
    Both job_id and signature from schedule_calculation are required to call this tool.
    Never call this without both values present in context.
    
    Args:
        job_id: The job ID returned by schedule_calculation.
        signature: The signature returned by schedule_calculation. Required for access.
        include_failed: Set to true to also return failed addresses with their error reasons. Default false.

Input parameters:

- `job_id` (string, required)
- `signature` (string, required)

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/chainaware-chainaware-behavioral-prediction-mcp/prediction#diagnostics

## Score history

- 2026-08-03: 49
- 2026-08-02: 48
- 2026-08-01: 48
- 2026-07-31: 32
- 2026-07-30: 45
- 2026-07-29: 48
- 2026-07-28: 47
- 2026-07-27: 26
- 2026-07-26: 25

## Links

- Remote endpoint: https://prediction.mcp.chainaware.ai/sse
- Authorisation metadata: https://prediction.mcp.chainaware.ai/.well-known/oauth-protected-resource/sse
- Changelog RSS feed: https://verifymcp.io/servers/chainaware-chainaware-behavioral-prediction-mcp/prediction/changelog.xml
- Changelog JSON feed: https://verifymcp.io/servers/chainaware-chainaware-behavioral-prediction-mcp/prediction/changelog.json
- HTML version of this page: https://verifymcp.io/servers/chainaware-chainaware-behavioral-prediction-mcp/prediction