Haris Guardian - Solana Token Risk Check
Server Details
Read-only Solana SPL/Token-2022 rug-risk check: 0-100 score (higher=riskier) with reasons.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
- Repository
- fitness9991/haris-guardian
- GitHub Stars
- 0
- ChatGPT
- –
- Claude
- –
TDQS
Scored across 4 tools
Each tool maps to a distinct mode: single free check, paid deeper check, batch of up to 20 mints, and a diff/watch against a previous result. The closest pair is check_solana_token vs deep_check_solana_token, which both return a score plus reasons; the descriptions clarify the difference (free/basic vs paid/holder-concentration), but an agent still has to reason about cost vs depth rather than the resource being touched.
All four names follow the same [modifier]_verb_object pattern anchored on solana_token(s): check_, deep_check_, batch_check_, diff_. A single predictable family with only a plural/singular variation that reads naturally for the batch case.
Four tools for a narrowly scoped token-risk service is well proportioned: basic, deep, batch, and diff each cover a genuinely different usage pattern rather than duplicating surface area. Nothing feels padded or conspicuously absent at the count level.
The surface covers the core lifecycle: quick screening, paid forensic depth, bulk screening, and change monitoring over time. Minor gaps remain — no batch deep-check, no wallet/creator-level risk endpoint, and no way to check x402 payment status or retrieve prior results by ID — but agents can work around these by chaining the existing tools.
Available Tools
4 toolsbatch_check_solana_tokensAInspect
Batch Solana token risk check (PAID, x402 over REST): up to 20 mints in one call for one flat price. This tool returns exact x402 payment instructions for POST /v1/paid/batch-check.
| Name | Required | Description | Default |
|---|---|---|---|
| mints | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries the full load, and it discloses two non-obvious traits: the call is paid via x402 over REST, and it returns exact payment instructions rather than risk results. That prevents a serious misuse, though it omits what the agent should do after paying and whether the result set comes back on a follow-up call.
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 tight sentences with the paid nature and batch cap in the first and the return behavior in the second. Nothing is redundant and the critical constraint is front-loaded.
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?
With one parameter and no output schema, the definition covers what the tool is and what it returns at a high level. It stops short of the operational detail a paid endpooint demands: the payment flow, whether the risk data arrives after settlement, and 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?
Schema description coverage is 0% with a single 'mints' array of strings, so the description must compensate. It adds a real constraint (max 20 per call) and clarifies that entries are token mints, but gives no address format, duplication, or invalid-mint handling guidance.
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 Solana token risk check') plus scale ('up to 20 mints in one call'), which distinguishes it in kind from the single-token siblings. It never names check_solana_token, deep_check_solana_token, or diff_solana_token, so the agent must infer the batch-vs-single split rather than being told.
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 batch limit and flat pricing imply 'use this when you have several mints to screen', but there is no explicit when-to-use versus the three sibling token tools and no stated exclusions. The 'PAID' marker hints at a free alternative path without saying so.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
check_solana_tokenAInspect
Scam/rug risk check for a Solana SPL or Token-2022 token mint. Returns a 0-100 risk score (HIGHER = RISKIER), a verdict, and flags with plain-English reasons: mint/freeze authority, permanent delegate, transfer hooks/fees, holder concentration, liquidity, LP burn/lock %, Streamflow locks and a simulated buy+sell (honeypot test). Read-only; never signs or trades.
| Name | Required | Description | Default |
|---|---|---|---|
| mint | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are supplied, so the description carries the burden and does well: it discloses read-only behavior, that it never signs or trades, the return shape (0-100 score, verdict, flags with plain-English reasons), and the specific checks performed including a simulated buy+sell honeypot test. It omits auth requirements, rate limits, or latency, keeping 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?
Front-loaded with the purpose and scoring direction, then the return payload, then the enumerated checks, closing with the safety constraint. Dense but every clause carries signal and none is filler.
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?
With no output schema and no annotations, the description adequately covers both what goes in and what comes back, including the risk-score polarity and the flag categories. The only real gap is sibling routing guidance, which matters given three adjacent check tools.
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 required parameter with 0% schema description coverage; the description clarifies that 'mint' means a Solana SPL or Token-2022 token mint address, which is meaningfully more than the bare string schema conveys. It does not specify the expected address format (base58 pubkey) or whether symbols are accepted.
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 scam/rug risk check for a Solana SPL or Token-2022 token mint, with the scoring direction (HIGHER = RISKIER) made explicit. It does not name or differentiate itself from siblings like deep_check_solana_token or batch_check_solana_tokens, so the agent must infer the boundary.
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 read-only, never-signs-or-trades framing implies a safe pre-trade screening use case, but there is no explicit guidance on when to reach for this versus deep_check_solana_token (deeper analysis) or batch_check_solana_tokens (multiple mints). Usage is inferable but not stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
deep_check_solana_tokenAInspect
Deep Solana token risk check (PAID, x402 over REST): holder concentration (top1/top5/top10 % of supply), top wallets linked by a shared funder (bundles/insiders), creator-funded holders, fresh wallets, LP lock/burn status, authorities, score + reasons. This tool returns exact x402 payment instructions for POST /v1/paid/deep-check; pay with any x402 client.
| Name | Required | Description | Default |
|---|---|---|---|
| mint | 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 reveals that the call does not return the analysis but instead returns exact x402 payment instructions for POST /v1/paid/deep-check, which is a critical non-obvious behavior. It still omits price, whether the call is per-mint billed, and what the agent should expect after payment settles.
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, front-loaded with the value proposition and the returned data set, with the payment caveat placed at the end where it reads as a call-to-action. The parenthetical feature list is long but each item is informative rather than filler.
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 one-parameter, no-output-schema tool, the description covers both the analytic payload and the unusual x402 payment flow, which is the main failure mode an agent could hit. The remaining gaps, cost and post-payment behavior for the mint parameter's expected format, are modest but real.
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 single required parameter 'mint' has 0% schema description coverage, so the schema contributes nothing and the description must compensate. It only implies the token via 'Solana token' and gives no address format, network qualifier, or example, leaving the agent to guess that 'mint' is a base58 mint address.
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 a specific resource (Solana token) and enumerates exactly what the deep check returns: holder concentration, shared-funder clusters, creator-funded holders, fresh wallets, LP lock/burn, authorities, and a score with reasons. The word 'deep' implies a more thorough counterpart to check_solana_token, but the sibling is never named, so differentiation is left to inference.
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?
It discloses the decisive usage fact that this is a PAID endpoint requiring x402 payment, which tells the agent not to call it casually. However, it never states when to prefer it over check_solana_token or batch_check_solana_tokens, nor what prerequisites (funded x402 wallet) are needed before calling.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
diff_solana_tokenAInspect
Watch/diff a Solana token: pass the mint and a previous Haris result (from check_solana_token or an earlier diff); returns alerts on what changed (authority re-enabled, LP unlocked, liquidity pulled, sell blocked, new red flags) plus the fresh result. Shares the free tier with check_solana_token; then x402 via POST /v1/paid/diff.
| Name | Required | Description | Default |
|---|---|---|---|
| mint | Yes | ||
| previous | 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 enumerates the alert categories (authority re-enabled, LP unlocked, liquidity pulled, sell blocked, new red flags) and discloses the billing model (shared free tier with check_solana_token, then x402 via POST /v1/paid/diff). It doesn't say whether the call is read-only/side-effect-free or what happens when `previous` is stale or malformed.
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 action and resource, then inputs, then outputs, then billing — a sensible order with no filler sentences. It is dense and semicolon-chained, which makes it slightly harder to scan than a fully structured version.
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 exists, and the description compensates by describing both return components (alerts on changes plus the fresh result). Billing and the prerequisite source of `previous` are covered; only edge behavior for an invalid or outdated `previous` payload is left unstated.
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 description coverage is 0% and `previous` is an untyped open object, so the description must compensate — and it does by identifying `mint` as the token mint and `previous` as a prior Haris result from check_solana_token or an earlier diff. It stops short of specifying the required shape or which fields of the prior result are actually diffed.
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 ("diff a Solana token") and defines the two-part output (change alerts plus the fresh result). It also names the sibling check_solana_token as the producer of the `previous` input, so an agent can tell it apart from check/deep_check/batch without opening a 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?
Clear usage context: this is the follow-up call you make with a stored result from check_solana_token or an earlier diff. It doesn't state exclusions (e.g. when to prefer deep_check_solana_token instead, or that a first-time check is required before diffing), which keeps it short of a 5.
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
batch_check_solana_tokens - First observed
check_solana_token - First observed
deep_check_solana_token - First observed
diff_solana_token
Related MCP Connectors
Solana token rug-pull detection for AI trading agents. Score, authorities, liquidity.
Solana token rug-risk scores. Free basic score; full report pay-per-call via x402 (0.03 USDC).
Solana token/wallet rug-risk scoring. Free scan; $2 SOL unlocks full wallet report. No signup.
Solana wallet & token reputation lookup. Risk verdict, score, DefiLlama TVL, Rugcheck.
Related MCP Servers
AlicenseAqualityBmaintenanceSolana token rug-risk scores. Free basic score tool; full report tool paid per call via x402 (0.03 USDC on Solana). Not financial advice.2492 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
- AlicenseAqualityAmaintenanceRug pull risk scores and on-chain forensics for memecoins on Solana, Ethereum, Base and Robinhood Chain - launch-bundle detection, funding-origin tracing, deployer history, insider networks and whale flow. 15 read-only tools.1532 npmMIT
- AlicenseAqualityCmaintenanceEnables pre-trade risk screening for EVM and Solana tokens, returning a one-line verdict with detailed flags on liquidity, ownership, and other risk factors.1MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.