Content
<p align="center">
<img src="./assets/banner.png" alt="TrustGate, the trust layer for Web3" width="100%" />
</p>
<h1 align="center">TrustGate MCP Server</h1>
<p align="center">
A trust layer for AI trading agents. Score any token before your agent buys it.
</p>
<p align="center">
<a href="https://www.npmjs.com/package/trustgate-mcp-server"><img src="https://img.shields.io/npm/v/trustgate-mcp-server?color=0a0a0a&label=npm" alt="npm version" /></a>
<a href="https://www.npmjs.com/package/trustgate-mcp-server"><img src="https://img.shields.io/npm/dm/trustgate-mcp-server?color=0a0a0a" alt="npm downloads" /></a>
<img src="https://img.shields.io/node/v/trustgate-mcp-server?color=0a0a0a" alt="node version" />
<img src="https://img.shields.io/npm/l/trustgate-mcp-server?color=0a0a0a" alt="license" />
</p>
<p align="center">
<a href="https://www.trustgated.xyz">Live site</a>
·
<a href="https://www.npmjs.com/package/trustgate-mcp-server">npm</a>
·
<a href="#quick-start">Quick start</a>
·
<a href="#the-tool">Tool reference</a>
</p>
<p align="center">
<img src="./assets/demo.gif" alt="An agent calling trustgate_score to vet a token before trading, returning a LOW score and an avoid verdict" width="100%" />
</p>
<p align="center">
<em>An agent vets a token with one call before trading. Score 11 of 100, tier LOW, verdict avoid.</em>
</p>
---
## Overview
Most AI trading agents trade blind on safety. They read price, sentiment, and on-chain signals, then route a buy without ever asking whether the token is legitimate or a scam about to rug.
TrustGate closes that gap. It exposes one Model Context Protocol tool, `trustgate_score`, that any agent can call on a token address before trading. The agent gets back a 0 to 100 legitimacy score, a tier, and a plain trade verdict. A scam scores low, the agent skips it, and no capital is lost.
The server runs on its own over stdio and sits alongside any other MCP server, including the Bitget Agent Hub. Your agent loads both and sees the full trading toolset and the TrustGate risk check in a single session.
## Why it exists
Scoring is derived from on-chain behavioral signals rather than self-reported metadata: holder distribution, deployer history, liquidity depth, trading patterns, and bot activity. The result is a single number an agent can gate on, with no breakdown to interpret and no model to run locally.
| Tier | Score | Verdict | Recommended agent action |
| :--- | :--- | :--- | :--- |
| `HIGH_ELITE` | 80 to 100 | `ok` | Trade. Strong trust signals. |
| `HIGH` | 60 to 79 | `ok` | Trade. |
| `MEDIUM` | 40 to 59 | `caution` | Trade only within a tight risk budget. |
| `LOW` | 1 to 39 | `avoid` | Skip. High risk. |
| `BLOCKED` | 0 | `avoid` | Skip. No usable history. |
| `NTT` | n/a | `not_tradeable` | Not a token. An NFT, a plain contract, or a wallet. |
## Quick start
The server runs directly from the registry. No global install, no build step.
```bash
npx -y trustgate-mcp-server
```
Register it in your MCP client of choice, then call `trustgate_score` from your agent.
### Claude Code
```bash
claude mcp add -s user trustgate -- npx -y trustgate-mcp-server
```
Add it next to the Bitget Agent Hub server. The agent then has the Bitget trading tools and `trustgate_score` in the same session.
### Cursor
Add to your MCP configuration (`.cursor/mcp.json` or the global config):
```json
{
"mcpServers": {
"trustgate": {
"command": "npx",
"args": ["-y", "trustgate-mcp-server"]
}
}
}
```
> Cursor caps the active toolset at around 40 tools. The Bitget default load is 36, so this single tool fits comfortably. Avoid loading Bitget's full module set at the same time.
### Codex
Add to `~/.codex/config.toml`:
```toml
[[mcp_servers]]
name = "trustgate"
command = "npx"
args = ["-y", "trustgate-mcp-server"]
```
## The tool
### `trustgate_score`
Returns a legitimacy and risk assessment for a token, intended to be called before an agent routes a trade.
| Parameter | Type | Required | Description |
| :--- | :--- | :--- | :--- |
| `address` | string | yes | The token contract address to score. |
| `chain` | string | no | The chain the token lives on. Defaults to `arc`. Informational. |
The tool returns a short human-readable summary and a structured result:
```json
{
"address": "0x8959ed0D7220e1bAa445106F48829Df0bF1e5F83",
"chain": "arc",
"score": 84,
"tier": "HIGH_ELITE",
"verdict": "ok",
"summary": "TrustGate score for 0x8959... on arc: 84/100, tier HIGH_ELITE. Looks legitimate. Safe to trade on trust grounds."
}
```
## How it fits a trading agent
The integration is a single gate between the agent's decision and its execution:
1. A signal fires. A token is moving, sentiment shifts, or an on-chain event lands.
2. Before routing the buy, the agent calls `trustgate_score` on the token.
3. If the verdict is `avoid` or `not_tradeable`, the agent skips and logs the reason.
4. If `ok` or `caution`, the agent sizes the position and trades through its existing tools.
One call. No change to how the agent trades, only a check it cannot easily skip.
## Configuration
| Variable | Default | Purpose |
| :--- | :--- | :--- |
| `TRUSTGATE_BASE_URL` | `https://www.trustgated.xyz` | Point at a staging deployment if needed. |
| `TRUSTGATE_TIMEOUT_MS` | `8000` | How long to wait on a score before treating the token as unverified. |
The tool fails soft. If the scoring endpoint is slow or unreachable, it returns tier `UNKNOWN` with verdict `unknown` rather than throwing, so an agent decides how to handle an unverified token instead of crashing its loop.
## Build from source
```bash
npm install
npm run build
node dist/index.js
```
Requires Node 18 or newer. The server speaks the Model Context Protocol over stdio and logs status to stderr, leaving stdout clean for the JSON-RPC stream.
## How scoring works
TrustGate scores tokens from public on-chain activity observed on Arc. The score reflects what an address has actually done rather than what it claims to be. The internal signal weights are not exposed through this tool by design; callers receive the score, the tier, and a verdict, which is everything an agent needs to make a routing decision.
The scoring backend is chain-agnostic, so the `chain` parameter extends to additional networks without any change to the tool interface.
## License
MIT
