TokenGuard
Server Details
Solana token rug check before you buy: SAFE/CAUTION/DANGER from chain state, paid per call via x402.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
TDQS
Scored across 4 tools
solana_token_check and solana_token_verdict both return risk verdicts and scores, with verdict being a cheaper, less detailed subset of check. The batch tool is clearly distinct, and descriptions mention price/output depth, but the overlap between check and verdict can easily cause misselection.
Three tools follow a consistent snake_case `solana_token_*` pattern (batch, check, verdict). tokenguard_info breaks the prefix but is clearly a server-level metadata tool, a minor and understandable deviation.
Four tools is a reasonable, well-scoped count for a token-screening service. Each has a distinct mode (batch, full check, summary verdict, info), though the check/verdict overlap means one tool feels somewhat redundant.
The surface covers single-token full checks, batch screening up to 10 tokens, a quick verdict, and service info. No critical gaps for a rug-check API, but historical or wallet-level monitoring tools are absent.
Available Tools
4 toolssolana_token_batchAInspect
Use when screening up to 10 new Solana tokens at once (sniping, watchlists): same output as the full check for each mint, half the per-token price. Costs 0.025 USDC (x402, Solana or Base).
| Name | Required | Description | Default |
|---|---|---|---|
| addresses | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and does well: it discloses the payment rail (x402 on Solana or Base), the exact cost (0.025 USDC), the batch ceiling, and that output equals the full check per mint. It omits failure/partial-batch behavior and latency, which keeps it short of a 5.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One front-loaded sentence that opens with the usage condition and follows with the cost/limit facts. Every clause carries information; nothing is padding.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter tool with no annotations and no output schema, the description covers when to use it, what it costs, and how the output relates to the sibling check. The remaining gap is that it never actually describes the returned screening fields, deferring entirely to "the full check."
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0% for the single `addresses` parameter, so the schema documents nothing beyond type and maxItems=10. The description implies the values are mint addresses and reiterates the 1–10 batch range but adds no format or ordering guidance, leaving the parameter only partially illuminated.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource: batch-screening up to 10 Solana tokens, with the scope limit called out. It also anchors itself to the sibling concept ("same output as the full check for each mint"), so an agent can tell it apart from the single-token check without opening either schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives a clear trigger ("Use when screening up to 10 new Solana tokens at once") with concrete scenarios (sniping, watchlists). It does not explicitly name solana_token_check as the alternative for a single mint or state when-not to batch, so routing is implied rather than spelled out.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
solana_token_checkAInspect
Use before any Jupiter or pump.fun trade on an unknown Solana mint: full rug check from chain state. Verdict, risk score, flags (freeze or mint authority, Token-2022 traps, wallet concentration, age, pump.fun creator dumping or serial launches), authorities, holders, creator. Costs 0.005 USDC (x402, Solana or Base).
| Name | Required | Description | Default |
|---|---|---|---|
| address | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and does substantial work: it discloses the data source ('chain state'), the return contents, and the payment/auth model ('Costs 0.005 USDC (x402, Solana or Base)'). It omits rate limits, latency, idempotency, and failure behavior, which is a real but moderate gap for a read-style check.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loaded with the usage trigger, then outputs, then cost, in a single dense passage with no filler. Every clause carries distinct information an agent needs.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema or annotations exist, so the description must stand alone; it covers when to call, what is returned, and the payment requirement. The remaining gap is the parameter format for the required 'address' field and any error behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Only one parameter at 0% schema coverage, and its name ('address') is ambiguous. The phrases 'Solana mint' and 'from chain state' weakly imply it expects a mint address rather than a wallet, but no format, encoding, or example is given. The description only partially compensates for the missing schema documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('full rug check from chain state' on a Solana mint) and enumerates the concrete outputs (verdict, risk score, flags, authorities, holders, creator). It does not differentiate itself from siblings solana_token_verdict or solana_token_batch, so an agent cannot tell from the description alone which of the three to pick.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives explicit trigger context: 'Use before any Jupiter or pump.fun trade on an unknown Solana mint.' The 'unknown mint' qualifier implies scoping versus known-good tokens. However, it never names the sibling alternatives (batch, verdict) or states when-not to use it, so routing remains partly inferential.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
solana_token_verdictAInspect
Use when your agent is about to buy or swap into an unknown Solana token: go/no-go rug check read from chain state. Returns SAFE/CAUTION/DANGER, 0-100 risk score and flags. Skip DANGER, reduce size on CAUTION. Costs 0.001 USDC (x402, Solana or Base).
| Name | Required | Description | Default |
|---|---|---|---|
| address | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden and does well: it discloses that the result is read from chain state, the exact output classes, the cost (0.001 USDC via x402) and payment chains (Solana or Base). Missing latency, caching, or failure behavior, but the paid-call requirement is a valuable behavioral disclosure the schema cannot express.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two dense sentences: the usage condition is front-loaded, then output, then decision rules and cost. No filler; each clause adds actionable information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema or annotations exist, yet the description covers return values, decision thresholds, and payment cost, which is what an agent needs to call it. It falls short only on the input address semantics and edge/error behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
One required parameter ('address') with 0% schema description coverage, and the description never names or explains it. The token-check framing implies it is a token mint address, which is some compensation, but format/expectations are left to inference.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource: a go/no-go rug check that reads chain state and returns a verdict. It clearly conveys what the tool produces (SAFE/CAUTION/DANGER plus score and flags). It does not differentiate itself from the siblings (solana_token_check, solana_token_batch, tokenguard_info), leaving ambiguity about which check flavor to pick.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives explicit triggering context ('about to buy or swap into an unknown Solana token') and even decision rules for acting on the result ('Skip DANGER, reduce size on CAUTION'). It stops short of saying when to prefer this over the sibling check/batch tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tokenguard_infoBInspect
Free: what TokenGuard checks, prices and how to pay (x402).
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden, and it does disclose one genuinely useful behavioral trait: the call is free, unlike the paid sibling tools reachable via x402. Beyond that it says nothing about what the response contains, whether it is safe/cached, or any rate limits, so the disclosure is thin for an annotation-free tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One short, front-loaded sentence with the cost-relevant word 'Free' first. Nothing is wasted, though the extreme brevity leaves little room for the routing hints an agent would benefit from.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is trivially simple (no params) but has no output schema, so the description is the only source of information about what comes back. It gestures at the content ('what TokenGuard checks, prices and how to pay') but never states the return shape, and it does not explain how to proceed to the paid sibling tools after reading it.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema is an empty object with zero parameters, so there is nothing for the description to disambiguate. Baseline 4 applies for a no-parameter tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names the resource ('TokenGuard') and enumerates the content it returns: what it checks, prices, and how to pay. That is specific enough to separate it from the sibling check/verdict/batch tools, which perform token operations. It lacks an explicit verb ('returns documentation about'), so it falls short of a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The only usage signal is the leading 'Free:', which implies the agent can call this at no cost, presumably before engaging the paid x402 flow. There is no explicit when-to-use, when-not-to-use, or named alternative among solana_token_check, solana_token_verdict, or solana_token_batch.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
4 tool updates
- First observed
solana_token_batch - First observed
solana_token_check - First observed
solana_token_verdict - First observed
tokenguard_info
Related MCP Connectors
Solana token rug/honeypot checks: free quick check; full score paid via x402 (USDC Solana/Base).
Pre-trade token safety checks for AI agents on Solana and Base. x402 USDC per call, no key.
Pay-per-call Solana token risk intelligence: 8 tools via x402. From $0.005 USDC, no API key.
Solana token/wallet rug-risk scoring. Free scan; $2 SOL unlocks full wallet report. No signup.
Related MCP Servers
- AlicenseAqualityAmaintenanceOn-chain Solana token safety for trading agents — traces coordinated wallet funding, same-block Jito bundles, serial-rug deployers and live coordinated dumps into one Exit-Liquidity Risk verdict before a swap. Free tier, then $0.02 USDC/query via x402.152 npm1MIT
- AlicenseNot gradedqualityCmaintenanceChecks token contract safety for honeypot, tax, proxy, blacklist, ownership risks, and returns a risk score, enabling rug-pull protection for agents via pay-per-call x402 micropayments.MIT
- AlicenseAqualityCmaintenancePaid access to Solana DeFi risk intelligence — rug/honeypot scans, liquidity-pool analysis, and wash-trade-filtered pool rankings. Automatically settles micropayments in USDC via x402.1068 npmMIT
- AlicenseAqualityBmaintenanceOn-chain rug-pull & honeypot risk screen for ERC-20 tokens, providing a SAFE / CAUTION / HIGH-RISK verdict based on live public RPC reads.2MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.