agiscorecard-web3-calls
Server Details
Decode supported token calls and flag recipient or amount mismatches; no wallet or safety verdict.
- Status
- Healthy
- Uptime
- 100.0% over 22 days
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
- Repository
- f-tiger/agi-site
- GitHub Stars
- 0
TDQS
Scored across 3 tools
decode_token_call has a clearly distinct purpose (local decoding/comparison of token calls), while search and fetch form a conventional lookup-then-retrieve pair that is easy to tell apart since search returns IDs and fetch consumes them. Boundaries are clear, though fetch/search are generic enough that an agent could briefly hesitate about which resource domain they serve.
decode_token_call uses a descriptive snake_case verb_noun_verb pattern, but fetch and search are bare single verbs, so the set mixes two conventions. Still readable, but not a predictable pattern across all three tools.
Three tools is thin for a server whose namesake capability is Web3 call decoding plus a documentation surface. The scope is narrow and coherent, but the set is borderline under-scoped rather than well-scoped.
The search-to-fetch pair fully covers the documentation lifecycle, and decode_token_call covers the core decode/compare operation. However, there is no way to enumerate supported token-call shapes or standards, no encode/validate counterpart, and decode is limited to whatever shapes are already supported, leaving notable gaps.
Available Tools
3 toolsdecode_token_callCall LensARead-onlyIdempotentInspect
Call Lens decodes supported token-call shapes locally and compares the recipient, spender and atomic amount with your expectations. It distinguishes ERC-20 allowances from ERC-721 token IDs using the declared standard. It never connects a wallet or evaluates contract safety. No chain simulation, malicious-contract detection, token identity lookup, balance inspection or safety verdict. Retrieve calls with fetch or read its example resource to obtain exact inputs. Parameters are processed remotely without application persistence.
| Name | Required | Description | Default |
|---|---|---|---|
| to | Yes | Target contract (preserve source text; decimal amounts must stay strings) | |
| data | Yes | Hex calldata (preserve source text; decimal amounts must stay strings) | |
| network | Yes | Network (preserve source text; decimal amounts must stay strings) | |
| tokenStandard | Yes | Token Standard (preserve source text; decimal amounts must stay strings) | |
| maxAtomicAmount | Yes | Amount limit (atomic units) (preserve source text; decimal amounts must stay strings) | |
| expectedRecipient | Yes | Expected recipient / spender (preserve source text; decimal amounts must stay strings) | |
| nativeValueAtomic | Yes | Native value (atomic units) (preserve source text; decimal amounts must stay strings) |
Output Schema
| Name | Required | Description |
|---|---|---|
| report | Yes | |
| toolId | Yes | |
| version | Yes | |
| citation | Yes | |
| revision | Yes | |
| processing | Yes | |
| limitations | Yes | |
| evidenceStatus | Yes | |
| officialReferences | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark readOnly, idempotent, and non-destructive. The description adds meaningful operational facts: local decoding, no wallet connection, no contract-safety evaluation, no application persistence, and remote processing. These constraints materially affect invocation expectations and go well beyond annotation coverage.
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?
The description is compact and front-loaded with the core purpose, followed by exclusions and input-retrieval instructions. Every sentence earns its place; there is no filler or redundant restatement of the tool name.
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 7-parameter tool with an output schema, the description covers purpose, exclusions, input retrieval, and persistence behavior. The only notable gap is that ERC-1155 appears in the enum but the description only illustrates the ERC-20 vs ERC-721 distinction.
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 schema covers all seven parameters with descriptions and an enum, so the description does not need to repeat per-parameter details. The text adds conceptual orientation around recipient/spender and atomic amount but no concrete parameter-level guidance beyond the schema. Baseline 3 is appropriate.
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 ('decodes') and object ('supported token-call shapes'), and frames the comparison against recipient, spender, and atomic amount. The negative capability list separates it from safety and simulation tools. Clear and differentiating.
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?
Names fetch and read as the way to retrieve calls and exact inputs, providing an explicit path to invocation. It also lists exclusions such as no chain simulation and no safety verdict, so an agent knows when not to use it. It does not name specific alternative tools for those excluded jobs.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
fetchRead a Web3 method and sourcesARead-onlyIdempotentInspect
Retrieve a public tool reference by the ID returned from search. Contains methodology, limits, official source links and fictional worked examples; no user records. Cite the returned canonical URL.
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| id | Yes | |
| url | Yes | |
| text | Yes | |
| title | Yes | |
| metadata | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint/idempotentHint/destructiveHint, so safety is covered. The description goes further by disclosing the payload contents (methodology, limits, official source links, fictional worked examples), asserting 'no user records', and prescribing a citation action on the canonical URL — useful context beyond annotations, with no contradiction.
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?
Three short clauses, front-loaded with the action and ID provenance, followed by content summary and a concrete instruction ('Cite the returned canonical URL'). No filler sentences.
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?
An output schema exists, so return values need not be explained, yet the description still qualifies contents; annotations cover the safety profile; the parameter's origin is stated. Complete enough to call correctly, with only the odd single-value enum left unaddressed.
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%, so the description must carry the weight for the single 'id' parameter. It partially compensates by stating the ID comes from 'search', but says nothing about the lone enum value 'calls' or the ID's expected format.
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 ('Retrieve') and resource ('public tool reference by the ID returned from search'), and the provenance phrase ties it to the sibling 'search' rather than leaving it ambiguous. An agent can distinguish it from search and decode_token_call without opening any 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?
The clause 'by the ID returned from search' establishes the prerequisite and sequencing (call search first), which is clear context for when this tool is used. It stops short of any explicit when-not or a named alternative, so it does not reach the top band.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
searchFind a Web3 worksheetARead-onlyIdempotentInspect
Search this server’s public AI/Web3 tools and citation pages. English and Chinese names supported. Empty query lists the available worksheets.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| results | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already establish read-only, idempotent, non-destructive behavior, and the description adds valuable behavioral context: bilingual (English and Chinese) name support, public scope, and the empty-query listing behavior. These details go beyond what annotations or schema provide without contradicting them.
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?
The description is two clean sentences with no filler. The primary action is front-loaded, and the supporting usage details are kept minimal and relevant.
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 search tool with annotations and an output schema, the description is complete: it defines the search scope, supported query forms, and the empty-query behavior. No essential information for invoking the tool correctly is missing.
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%, so the description carries the burden of explaining the query parameter. It clarifies that queries are names, that English and Chinese are accepted, and that an empty query has special meaning. It does not fully specify matching behavior (e.g., exact vs partial), but it compensates well for the schema gap.
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 states a specific verb ('Search') and resource ('this server’s public AI/Web3 tools and citation pages'), making the tool’s function immediately clear. It is distinct from all sibling tools, which focus on checking permissions, comparing costs, or reading profiles rather than searching a corpus. The title and description align well.
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 description clearly indicates when to use the tool: when searching for AI/Web3 tools or citation pages on this server. The note about empty query listing available worksheets provides a concrete usage scenario. It does not explicitly name alternatives or exclusion conditions, so it misses the top score.
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.
3 tool updates
- First observed
decode_token_call - First observed
fetch - First observed
search
Related MCP Connectors
Read-only crypto safety: token honeypot checks, EIP-712 signature decode, approval scans.
Decode any Base tx: plain English, strict JSON, risk flags, no LLM. 50 free/day per IP, then $0.02.
Read-only honeypot, holder and liquidity scam checks for tokens across 64 networks.
Token intent checks; no simulation/signing. Free trial ends 2026-09-25. No NFT required.
Related MCP Servers
- AlicenseAqualityCmaintenanceDecodes Ethereum calldata and returns a safety verdict with plain-English explanations of what the transaction does, flagging dangerous actions like unlimited approvals or gasless permits.2MIT
- AlicenseBqualityCmaintenanceProvides on-chain forensic checks for evaluating transaction risks, including token verification, rug-pull detection, and fund tracing, using public blockchain endpoints.1251 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
- AlicenseAqualityDmaintenanceDecodes raw EVM bytes into human-readable JSON via tools for logs, calldata, selectors, and ABIs across multiple chains. Read-only, keyless, and stateless, with optional x402 payment settlement.4MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.