evmscope

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v1.7.0
Disambiguation4/5
Most tools have distinct purposes focused on specific EVM/DeFi tasks, but some overlap exists: getBalance and getPortfolio both retrieve wallet balances, and getTokenInfo/getTokenPrice both provide token data. Descriptions help clarify differences, but an agent might occasionally misselect between closely related tools.
Naming Consistency5/5
Tool names follow a highly consistent camelCase pattern with a clear 'verbNoun' structure (e.g., getBalance, decodeTx, simulateTx). All 26 tools adhere to this convention, making them predictable and easy to parse programmatically.
Tool Count3/5
With 26 tools, the count feels heavy for a single server, bordering on excessive. While the tools cover a broad EVM/DeFi scope, the set could benefit from consolidation or modularization to reduce cognitive load and potential overlap.
Completeness5/5
The toolset comprehensively covers EVM/DeFi operations: from basic queries (balances, gas, blocks) to advanced features (simulations, honeypot detection, bridge routes, governance). There are no obvious gaps; agents can perform end-to-end workflows like token analysis, portfolio management, and transaction handling.
Average 3.7/5 across 26 of 26 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- 0 of 1 community issues answered or closed in the last 6 months
- 1 commit in the last 12 weeks
- Last stable release on March 10, 2026
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It adds valuable context that USD conversion is included in the response, which helps set expectations. However, it omits other critical behavioral details such as whether the tool performs real-time blockchain queries or uses cached data, timeout behavior, or what happens if invalid token symbols are provided.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core action. However, given the absence of annotations and output schema, it errs on being overly terse rather than appropriately informative for agent decision-making.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 3 parameters, no annotations, and no output schema, the description provides minimum viable context by mentioning USD conversion. However, it lacks information on return structure, array handling for multiple tokens, error responses, or chain-specific behaviors that would help an agent invoke the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema has 100% description coverage with clear parameter documentation. The description mentions 'native token + ERC-20 token' which loosely maps to the 'tokens' array parameter semantics, but does not add syntax details, examples, or constraints beyond what the schema already provides. Baseline 3 is appropriate given high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool queries (조회합니다) native token and ERC-20 token balances with USD conversion. It specifies the resource (wallet address balances) and scope (native + ERC-20). However, it does not explicitly differentiate from sibling 'getPortfolio' which may also return balance-related data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No usage guidance is provided. There is no indication of when to use this versus 'getPortfolio' or 'getTokenInfo', no prerequisites (e.g., address format validation), and no mention of error conditions or rate limits.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses Ethereum mainnet restriction ('Ethereum mainnet 전용'), which is crucial behavioral context given no annotations. However, lacks disclosure on failure modes (what happens if ENS unregistered?), whether resolution is cached, rate limits, or read-only nature (inferred but not stated).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence efficiently conveys core function and network constraint. No wasted words. Front-loaded with action verb ('해석합니다'). Slight penalty for brevity that sacrifices completeness regarding return values and error handling.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Adequate for a single-parameter lookup tool, but lacks description of return structure (address string vs object? forward vs reverse resolution indicator?) given no output schema exists. No mention of null/empty response handling for unregistered names.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with parameter 'nameOrAddress' already documented with examples (vitalik.eth, 0x...). Tool description reinforces bidirectional capability but adds minimal semantic value beyond the complete schema. Baseline 3 appropriate per criteria for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states bidirectional resolution between ENS names and Ethereum addresses with the ↔ symbol and '양방향으로' (bidirectionally). Specifies Ethereum mainnet scope, distinguishing from potential multi-chain siblings. Falls short of 5 by not explicitly differentiating from 'identifyAddress' sibling which may also resolve address metadata.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides no guidance on when to use this tool versus siblings like 'identifyAddress' or 'getBalance'. Does not mention prerequisites (e.g., ENS name must be registered) or failure scenarios (unregistered names).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses what classifications the tool provides (exchange, DeFi, whale, contract/EOA), but lacks operational details like data source (on-chain vs off-chain), handling of unknown addresses, or whether classifications are exclusive or ranked.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Extremely concise single sentence with parenthetical elaboration. Front-loaded with action verb, zero redundancy, no filler. Korean text is efficient and every character earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 2-parameter tool with 100% schema coverage and no output schema, the description covers the core classification value proposition. However, given no output schema exists, it could benefit from mentioning what form classifications take (labels, categories, confidence scores) to help the agent consume the result.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with clear descriptions for both parameters ('Ethereum address (0x...)', 'Chain (ethereum, polygon...)'). The description adds no additional parameter guidance (e.g., address format validation, case sensitivity, or chain selection rationale), meriting the baseline score for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
States specific action (식별/identify) and target resource (주소/address) with concrete classification categories (exchanges, DeFi protocols, whale wallets, contract/EOA). Clearly distinguishes from siblings like getBalance, resolveENS, or getTokenInfo by focusing on entity classification rather than balances, name resolution, or token metadata.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides no guidance on when to use this tool versus alternatives. Does not indicate when to prefer this over getTokenInfo for contract addresses, or getContractABI for contracts, or how it differs from getWhaleMovements which also involves whale wallets.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It successfully discloses the output structure (function names, logs, gas data) which compensates for the missing output schema. However, it fails to disclose other behavioral traits like read-only safety, error handling for invalid hashes, or rate limiting.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single efficient sentence with a parenthetical clarifying the JSON contents. Every element earns its place: the verb defines the action, the format specifies the output structure, and the parenthetical lists the specific decoded components without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of output schema, the description appropriately compensates by detailing what the structured JSON contains (function name, parameters, logs, gas). For a 2-parameter decoding tool, this is sufficient, though it could be improved by noting read-only nature or supported chains.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% (both `txHash` and `chain` are well-documented in the schema). The description focuses entirely on the output behavior and adds no additional parameter semantics, meeting the baseline expectation for high-coverage schemas.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool decodes/parses (해석합니다) transactions into structured JSON, specifying exactly what data is extracted (function name, parameters, event logs, gas info). However, it does not explicitly differentiate from siblings like `getTxStatus` or `simulateTx`, which also interact with transactions but for different purposes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It does not indicate when to prefer this over `getTxStatus` (for confirmation status) or `simulateTx` (for simulating future transactions), nor does it mention prerequisites like having a valid transaction hash.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full disclosure burden and succeeds in communicating key behavioral traits: it notes the '주요 프로토콜 자동 체크' (auto-check major protocols) functionality and '리스크 레벨 판정' (risk level determination), indicating this performs analysis beyond raw data retrieval. However, it omits explicit read-only safety disclosure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Extremely compact with two efficient phrases delivering the core purpose and key features without redundancy. The telegraphic style ('주요 프로토콜 자동 체크, 리스크 레벨 판정') sacrifices grammatical completeness for brevity but remains interpretable, though a full sentence structure would improve clarity slightly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the good schema coverage (100%) but absence of annotations and output schema, the description adequately covers the tool's purpose and special features (risk assessment). However, it lacks disclosure of return value structure (allowance amounts, risk ratings) which would be expected for a complete specification without output schema documentation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 100% schema description coverage, the structured schema already fully documents all 4 parameters (owner, token, spender, chain). The description doesn't add syntax, format constraints, or examples beyond the schema declarations, warranting the baseline score of 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action (조회합니다/query) and resource (ERC-20 토큰 승인/allowance 상태), distinguishing it from siblings like getBalance or getTokenInfo which handle different token aspects. It effectively identifies the tool's domain as ERC-20 allowance checking.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no explicit guidance on when to use this tool versus alternatives (e.g., when to check approvals vs token balances), nor does it mention prerequisites like requiring an owner address. The risk assessment feature is mentioned but not contextualized with usage scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full disclosure burden. It implies a read-only operation via '조회합니다' (retrieves) and lists return fields, but omits error handling (e.g., invalid token), rate limits, or whether historical vs current data is returned.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence with zero waste. Front-loaded with the specific resource (ERC-20 metadata) and action, followed by parenthetical field enumeration. Every element earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 2-parameter read operation with no output schema, the description adequately compensates by listing the four return value fields. However, it lacks error behavior details that would be expected given the complexity of blockchain address resolution.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% for both parameters (token, chain), establishing a baseline of 3. The description mentions ERC-20 which adds context to the 'token' parameter, but doesn't expand on input formats or the 'chain' enum beyond the schema definitions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves ERC-20 token metadata with specific fields (name, symbol, decimals, total supply) and uses a specific verb (조회합니다/retrieves). However, it lacks explicit differentiation from siblings like getTokenPrice or getNFTInfo, which handle different aspects of tokens.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this tool versus alternatives (e.g., getTokenPrice for pricing, getBalance for holdings) or prerequisites. Users must infer from the parameter descriptions alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, the description carries the full burden of behavioral disclosure. It specifies the return data points (price in USD, volatility, market cap, volume) and implies real-time data via '현재' (current), but lacks critical context: error behavior for invalid tokens, data freshness/staleness, rate limits, or whether the data is aggregated from specific exchanges.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, zero waste. Front-loads the subject (token price) and parenthetically clarifies USD currency. Lists four return metrics efficiently without filler, appropriate for the tool's straightforward purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite lacking an output schema, the description compensates by explicitly enumerating the four return fields (price, 24h change, market cap, volume). This provides sufficient completeness for a read-only data retrieval tool with simple inputs, though it omits error case descriptions.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, documenting that 'token' accepts symbols or contract addresses and 'chain' specifies EVM networks. The description does not add parameter-level semantics (e.g., address format requirements, case sensitivity for symbols), so it meets the baseline of 3 when schema coverage is comprehensive.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the tool retrieves four specific financial metrics (current USD price, 24h change rate, market cap, trading volume) using the verb '조회합니다' (retrieves/inquires). This specificity distinguishes it from generic siblings like 'getTokenInfo' by implying a focused price/market-data scope, though it doesn't explicitly name alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance provided on when to use this versus siblings like 'getTokenInfo' (which may overlap) or 'getPortfolio' (which aggregates prices). No mention of prerequisites, such as requiring an exact token symbol or contract address format.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of disclosure. It partially compensates by listing the specific status values and metrics returned (confirmations, gas usage), but omits operational details such as error handling for invalid hashes, rate limits, or caching behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single efficient sentence that front-loads the action verb and appends return value details in parentheses. There is no redundant text or unnecessary elaboration; every element serves a specific communicative purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (two flat parameters) and lack of output schema, the description adequately compensates by enumerating the key return fields (status, confirmations, gas). It is complete enough for selection, though it could benefit from noting behavior for non-existent transaction hashes.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage for both parameters (txHash and chain), establishing a baseline of 3. The description adds no supplemental context about parameter semantics, such as the expected format of the transaction hash or implications of the chain default value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool queries (조회합니다) transaction status and lists specific return fields (pending/success/failed, confirmations, gas usage), which helps define scope. However, it does not explicitly differentiate from siblings like decodeTx or simulateTx, which also interact with transaction data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives such as decodeTx (for full transaction details) or simulateTx (for pre-submission validation). There are no prerequisites, conditions, or exclusion criteria mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full disclosure burden. It successfully notes key behaviors (ABI auto-decoding, default recent 1000-block range, block range flexibility), but omits critical operational details like read-only safety confirmation, pagination behavior with the 'limit' parameter, or error handling when contracts are unverified.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Perfectly concise Korean description structured as a single declarative sentence with high-value parenthetical details. Every clause earns its place: auto-decoding (differentiator), default range (behavioral constraint), and range flexibility (capability). No redundancy or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Adequate for basic invocation given the well-documented schema, but gaps remain due to missing output schema (no hint on decoded event structure) and missing annotations. For a blockchain query tool with 4 parameters and complex decoding logic, the description should ideally disclose output format or caching behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema has 100% description coverage, establishing a baseline of 3. The description adds high-level context about the 1000-block default window which clarifies fromBlock's implied scope, but does not augment parameter syntax, formats, or interdependencies (e.g., how limit interacts with block range) beyond what the schema already documents.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('조회합니다' / retrieve) and resource ('컨트랙트 이벤트 로그'), and distinguishes itself from siblings like decodeTx or getTokenTransfers by highlighting 'ABI 자동 디코딩' (auto-decoding), implying it handles the full pipeline from raw logs to decoded events.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides implicit usage guidance through parenthetical constraints (default 1000-block window, block range capability), helping agents understand the query window behavior. However, it lacks explicit guidance on when to use this versus alternatives like decodeTx or getContractABI, and does not mention prerequisites (e.g., contract verification for decoding).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full disclosure burden. It successfully compensates by detailing the response structure (3-tier speed levels) and units (Gwei plus USD conversion), giving the agent clear expectations of what data structure will be returned despite the lack of output schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence with parenthetical clarification is optimally efficient. Every element earns its place: verb (조회합니다), resource (가스비), granularity (3단계), and output format (Gwei + USD). No redundant words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple single-parameter read operation, the description adequately compensates for the missing output schema by describing the expected return structure (three speed tiers with dual currency units). Given the tool's simplicity, this level of detail is sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema has 100% coverage with the 'chain' parameter well-documented as 'EVM 체인'. The description does not mention the parameter, but with complete schema coverage, the baseline score of 3 is appropriate as no compensation is needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the tool retrieves (조회합니다) current gas prices using specific tiers (slow/normal/fast) and output format (Gwei + USD). However, it does not explicitly distinguish from sibling tool 'compareGas', which likely serves a similar but distinct purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance provided on when to use this tool versus alternatives like 'compareGas', nor are there any prerequisites or conditions mentioned. The user must infer appropriate usage from the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full behavioral disclosure burden. It specifies ERC-721 standard and mentions tokenURI (indicating part of return data), but lacks safety disclosures (read-only status), pagination behavior, rate limits, or error handling details. '조회합니다' (queries/retrieves) implies read-only but this is not explicit.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, front-loaded with specific verb (조회합니다). Efficiently packs resource (ERC-721 NFT list, tokenURI), scope (specific contract), and target (wallet address) with zero redundancy. Appropriate length for the complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 3 parameters and 100% schema coverage but no output schema, the description appropriately mentions tokenURI to hint at return structure and specifies ERC-721 standard to constrain scope. Could benefit from describing the full return object format or pagination since no output schema exists, but adequately complete for tool selection.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has 100% description coverage. Description mentions '지갑 주소' (wallet address) and '특정 컨트랙트' (specific contract), matching schema fields, but adds no syntax details, format examples, or constraints beyond what the schema already documents. Baseline 3 applies for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clear specific verb (조회합니다/retrieve) with explicit resource (ERC-721 NFT 목록/list of ERC-721 NFTs). Distinguishes from sibling getNFTMetadata (which implies individual metadata lookup) by specifying wallet-held asset listing scope and tokenURI retrieval. Precisely defines the operation's bounds.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit when-to-use guidance, comparisons to siblings (e.g., when to use getPortfolio vs this), or prerequisites mentioned. The phrase '특정 컨트랙트에서' (from a specific contract) implies contractAddress necessity but does not constitute usage guidance versus alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description carries the full burden since no annotations are provided. It compensates well by disclosing the specific output fields returned (timestamp, transaction count, gas usage, validator), clarifying what 'detailed information' actually means. However, it lacks explicit statements about read-only safety, rate limits, or error behaviors.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Single well-structured Korean sentence efficiently conveys the tool's purpose. The parenthetical listing of return fields adds density without clutter. Front-loaded with the action verb (조회합니다/query) followed immediately by the resource and modifiers.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema exists, but the description proactively lists the four key data points returned (timestamp, tx count, gas, validator), which partially compensates. With 100% schema coverage on inputs and only 2 simple parameters, the description provides adequate context for invocation, though EVM-specific behavior could be explicit.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, establishing a baseline of 3. The description adds value by illustrating the 'latest' usage pattern for blockNumber and contextualizing the query action, but doesn't expand significantly on the chain parameter semantics beyond the schema's existing documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clear verb (조회합니다/retrieves) and specific resource (block detailed info) with concrete field enumeration. Distinguishes from transaction-level siblings (getTxStatus) and account-level tools (getBalance) by specifying block-level data like validators and gas usage. However, it doesn't explicitly contrast with getContractEvents or other block-adjacent tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides implicit usage guidance by mentioning the 'latest' keyword option for querying the most recent block, but lacks explicit when-to-use guidance versus alternatives like getTxStatus or getContractEvents. No mention of prerequisites (connecting wallet, network selection implications).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, description carries full burden. Valuably discloses data source hierarchy (Etherscan primary, Sourcify fallback) and contract verification requirement. Missing error behavior (what happens if unverified) and return format details.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence front-loaded with action, parenthetical efficiently packing source chain and requirements. No redundancy; every clause adds value regarding implementation or prerequisites.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Acceptable for 2-parameter tool with complete schema coverage. Covers data sources and verification constraint, but lacks output description (critical given no output schema) and failure modes (unverified/partial verification handling).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, establishing baseline 3. Description adds no explicit parameter guidance, but parenthetical context ('0x...' implied by address context) is implicitly clear. No additional semantic value needed given complete schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clear verb (조회/retrieve) and resource (contract ABI) with specific implementation details (Etherscan → Sourcify fallback). Inherently distinguishes from siblings like getContractEvents or getTokenInfo by focusing on ABI retrieval, though it could explicitly contrast with identifyAddress or decodeTx.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
States prerequisite 'verified contract needed' implying when not to use (unverified contracts), but lacks explicit guidance on alternatives (e.g., 'use decodeTx if unverified') or when this is preferred over reading from local cache.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full disclosure burden and adds valuable behavioral context: exchange deposit/withdrawal direction determination and summary statistics. However, it omits critical safety and operational characteristics (read-only status confirmation, rate limits, data freshness) that agents require when annotations are absent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The single-sentence description packs three distinct informational elements (tracking capability, exchange analysis feature, summary statistics) with zero redundancy. The information is front-loaded and every clause contributes unique functional context while maintaining exceptional brevity appropriate for the tool's scope.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given full input schema coverage but no output schema, the description partially compensates by mentioning return characteristics (summary statistics, direction determinations). However, for a 4-parameter blockchain analysis tool without annotations, it should ideally disclose output structure, pagination behavior, or data freshness to be fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema achieves 100% description coverage with clear documentation for all four parameters including token symbols, chain enums, and thresholds. Since the schema fully documents all parameters, the description appropriately relies on this structured documentation without redundancy, meeting the baseline expectation for high-coverage schemas.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description employs a specific action verb '추적합니다' (tracks) targeting '대규모 토큰 전송' (large-scale token transfers/whale movements), clearly identifying the resource and operation. It effectively distinguishes from siblings like `getTokenTransfers` by specifying unique whale-specific analysis features including exchange deposit/withdrawal direction determination.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage scenarios through mention of exchange direction analysis and summary statistics, but lacks explicit guidance on when to prefer this tool over `getTokenTransfers` or other monitoring alternatives. No explicit 'when-not-to-use' criteria or sibling comparisons are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full disclosure burden. It adds valuable context about what gets analyzed (매수/매도 세금, 위험도, 플래그/buy-sell taxes, risk, flags) and the external dependency (Honeypot.is 기반). However, it lacks disclosure on error handling, rate limits, data freshness, or whether this triggers any blockchain transactions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Extremely efficient single-sentence structure with parenthetical elaboration. Every element earns its place: the core function, specific check criteria, and data source attribution. No redundancy or filler content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 2-parameter fraud detection tool with 100% schema coverage, the description is nearly complete. It hints at return values by listing checked criteria (taxes, risk, flags). Minor gap: explicit mention of output structure or reliability warnings would perfect it, given the high-stakes nature of financial fraud detection.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the schema already clearly documenting both parameters (token as address/symbol, chain as EVM enum with defaults). The description mentions '토큰' but adds no semantic meaning beyond what the schema already provides, warranting the baseline 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly specifies the verb (탐지합니다/detects), resource (토큰/token), and specific scope (허니팟/사기 여부/honeypot fraud status). It distinguishes from siblings like getTokenInfo by focusing specifically on fraud detection rather than general metadata.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
While the specific domain (fraud detection) implies usage context, there is no explicit guidance on when to use this versus getTokenInfo or getApprovalStatus, no prerequisites mentioned, and no warnings about relying on external Honeypot.is data.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full disclosure burden. It successfully identifies the third-party provider (LI.FI) and evaluation criteria (cost/time comparison, optimal recommendation). However, it omits safety profile confirmation (read-only vs transactional), rate limits, or real-time vs cached data disclosure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Single efficient sentence with action front-loaded (조회합니다) and supporting details parenthetically organized. No redundant words. Korean language allows dense information packing without losing clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 4-parameter query tool with complete schema coverage, the description adequately covers functionality, provider, and value-add features. While output schema is absent, the description hints at return value (optimal route recommendation). Minor gap: explicit read-only confirmation would strengthen given lack of annotations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with clear Korean descriptions for all 4 parameters (출발/도착 체인, token formats, human-readable amount). The description adds no additional parameter constraints or relationships beyond the schema, warranting the baseline score for high-coverage schemas.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb (조회합니다/query) with clear resource (cross-chain bridge routes), specifies the provider (LI.FI), and delineates key features (cost/time comparison, optimal recommendation). It clearly distinguishes from siblings like getSwapQuote by emphasizing cross-chain bridging and route comparison.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage through 'cross-chain' and 'LI.FI based' keywords, suggesting when to use it (for bridging across chains). However, it lacks explicit 'when to use vs alternatives' guidance, particularly regarding differentiation from getSwapQuote or when bridging is preferable vs swapping.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It usefully discloses data composition (native + ERC-20, USD value, ratios) and aggregation behavior ('한 번에' / at once), but lacks operational details like read-only nature, rate limits, authentication requirements, or error handling for invalid addresses.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Single well-constructed sentence with efficient parenthetical specification of return data components. Every element earns its place—no fluff, no tautology, front-loaded with the core action and resource.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite lacking an output schema, the description compensates by explicitly enumerating return data components (native tokens, ERC-20, USD value, ratios). For a read-only portfolio aggregation tool, this provides sufficient completeness, though specific response format or pagination details could strengthen it further.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 100% schema description coverage (address and chain fully documented), the description appropriately does not redundantly explain parameters. It meets the baseline score of 3 where structured schema already provides complete semantic coverage, though it adds no supplementary parameter guidance.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action (query/retrieve) and resource (wallet's total asset portfolio), including detailed scope (native + ERC-20 tokens, USD value, ratios). It effectively distinguishes from siblings like getBalance (single token) or getTokenInfo (metadata) by emphasizing 'total portfolio' and 'at once' aggregation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
While it doesn't explicitly name alternatives, the description implies usage through scope specification—'total asset portfolio' signals this is for comprehensive aggregation rather than individual token lookups. However, it lacks explicit when-to-use guidance comparing against getBalance or getTokenInfo siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It adds temporal scope ('최근' / recent) and hints at return structure (deposits/withdrawals, token name, quantity). However, it lacks disclosure on pagination behavior, data freshness/caching, rate limits, or API key requirements that would be essential for a blockchain data tool without safety annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence with zero redundancy. Front-loaded with action verb and resource, parenthetical details provide precise return field documentation without verbosity. Every element earns its place in a compact Korean sentence structure.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 3-parameter tool with no output schema, the description compensates by listing return fields (deposits/withdrawals, token name, quantity). Missing details on pagination (despite limit parameter hinting at it) and data source freshness prevent a 5, but the essential contract is clear.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% (address, chain, limit all documented). The description implies the address parameter context ('지갑 주소의' / of wallet address) but does not add syntax details, validation rules, or usage examples beyond the schema. With complete schema coverage, baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses specific verb '조회합니다' (retrieves/queries) with clear resource scope: 'ERC-20 토큰 전송 내역' (ERC-20 token transfer history). It distinguishes from siblings like getBalance (current state) by specifying historical transfers with directionality (입금/출금 deposits/withdrawals), and from getTokenInfo (metadata) by focusing on transaction history. The parenthetical details (token name, quantity) clarify the data fields returned.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit when-to-use guidance or alternative naming. While 'ERC-20' implicitly distinguishes from NFTs (getNFTInfo) and native currency, it does not explicitly state when to choose this over getPortfolio (aggregated balances) or getTxStatus (specific transaction lookup). Usage is implied by the description but lacks explicit decision criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full disclosure burden. It adds critical behavioral constraints not in the schema: the result set is limited to 'top 10 pools by TVL' and the data source is DefiLlama. However, it omits explicit read-only confirmation, rate limiting, or authentication requirements.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Extremely compact single-sentence structure with parenthetical elaboration. Every clause earns its place: main action, data source, filter types, and result scope. No redundancy or wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description adequately compensates by specifying the result structure (top 10 pools) and data source. With 3 optional parameters fully documented in schema, the description provides sufficient context for invocation, though explicit return value format hints could strengthen it further.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, establishing baseline 3. The description aggregates the filtering intent ('프로토콜/체인별 필터') but does not add parameter-specific syntax, valid enum values, or formatting details beyond what the schema already documents.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb (조회합니다/retrieves) and resource (DeFi yield rates/APY), specifies the data source (DefiLlama-based), and clearly distinguishes from siblings like getProtocolTVL (which returns TVL metrics) by explicitly targeting '수익률(APY)'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description mentions available filters (protocol/chain-specific) and TVL criteria, providing implied usage context for when to apply this tool. However, it lacks explicit 'when-not-to-use' guidance or named alternatives (e.g., 'use getProtocolTVL for total value locked instead of yields').
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full disclosure burden. It successfully reveals key behavioral outputs (USD gas conversion, revert reason decoding, eth_call methodology) but omits critical operational context: it does not explicitly state that this is read-only and state-safe, nor does it mention potential rate limits or that 'from' address must be valid for simulation even without signing.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Extremely efficient single-sentence structure front-loaded with the action verb. Parenthetical enumeration of three distinct capabilities (eth_call+estimateGas, USD conversion, revert decoding) packs maximum information density without redundancy. Every element earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
In absence of an output schema, the description commendably identifies the three key return components (gas estimate, USD value, revert reason). However, it stops short of describing the return structure format or error handling patterns, which would be necessary for complete context given the tool's complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, establishing a baseline of 3. The description adds implicit context via 'eth_call + estimateGas' which hints at the Ethereum transaction structure (to/data/value), but does not add explicit syntax guidance, validation rules, or format details beyond what the schema already provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('시뮬레이션합니다'/simulates) with clear resource (transaction) and technical scope. Parenthetical details (eth_call + estimateGas, USD conversion, revert decoding) precisely distinguish it from siblings like decodeTx (post-hoc decoding) and getTxStatus (live transaction monitoring) by emphasizing pre-execution simulation capabilities.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
While 'simulation' implies pre-flight usage before submission, the description lacks explicit guidance on when to choose this over alternatives (e.g., 'use before submitting transactions' or 'not for querying confirmed transaction status'). The usage relative to siblings is implied by functionality rather than stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full disclosure burden. It successfully communicates output formatting (lowest-first sorting, USD estimates) and scope limitation (5 chains). However, it omits operational details like whether data is real-time vs cached, specific chain identifiers, or rate limiting concerns.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence construction with action-front-loaded structure ('5개 EVM 체인의 가스비를 한 번에 비교합니다'). Parenthetical details (sorting order, USD inclusion) efficiently append without verbosity. Zero redundant content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter tool without output schema, the description adequately conveys return value characteristics (sorted comparison with USD estimates). Minor gap exists regarding specific chain identification (which 5 chains), but sufficient for tool selection given the explicit '5 chains' quantifier.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema contains zero parameters, establishing a baseline of 4 per evaluation rules. The description appropriately requires no parameter explanation, as the empty schema properties object confirms this is a parameter-free comparison utility.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool compares gas fees across 5 EVM chains, using the specific verb '비교합니다' (compare). It distinguishes from sibling 'getGasPrice' by emphasizing multi-chain scope (5 chains) and added features (sorting, USD conversion), which implies aggregation behavior beyond single-chain queries.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage through its scope (5 chains vs single), suggesting use when users need comparative cross-chain data rather than individual chain data. However, it lacks explicit guidance on when to prefer this over 'getGasPrice' or other siblings, and states no prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses data source (Snapshot-based) and return payload richness (includes voting results). However, lacks critical behavioral details expected with no annotations: error handling for invalid spaces, rate limits, data freshness, or pagination behavior beyond the limit parameter.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Single efficient Korean sentence with action front-loaded and supplemental details in parentheses. No redundancy; every clause earns its place by conveying scope, filtering capability, or return data.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Appropriate for a read-only retrieval tool with 100% schema coverage. Compensates for missing output schema by disclosing that voting results are included. Could strengthen by noting Snapshot API dependency or error conditions, but adequate for invocation decisions.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 100% schema coverage, baseline is 3. Adds value by contextualizing 'protocol' as Snapshot space IDs (e.g., 'aave.eth') via 'Snapshot 기반' phrase, and clarifies state parameter outcomes ('상태 필터') and return data ('투표 결과 포함').
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Specific verb (조회/retrieve) + specific resource (Snapshot-based DeFi governance proposals) clearly distinguishes from sibling token/transaction tools like getTokenInfo or getBalance. Identifies the external platform (Snapshot) and data type.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Implies usage context (when querying governance proposals) but lacks explicit prerequisites (e.g., valid Snapshot space ID format), when-not-to-use guidance, or alternatives. No siblings overlap with governance domain, so differentiation is implicit rather than stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. Adds valuable behavioral detail 'IPFS URI 자동 변환 지원' (automatic IPFS URI conversion support), but omits other critical behaviors like error handling for non-existent tokens, rate limits, or return structure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with zero waste: first states core function with specific fields, second adds IPFS feature. Front-loaded with primary purpose. Korean text is appropriately compact.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema exists, but description compensates by enumerating returned metadata fields (name, description, image, attributes). Given 100% input schema coverage and lack of annotations, description provides adequate completeness for tool selection.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, baseline 3. Description adds semantic value by specifying 'ERC-721' (constraining contractAddress type) and implying the specific metadata standard being queried, which helps agent understand parameter intent beyond schema definitions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description uses specific verb '조회합니다' (retrieve) with explicit resource 'ERC-721 NFT 메타데이터' (metadata). Lists specific fields (name, description, image, attributes) to distinguish from sibling getNFTInfo which likely returns broader info.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides implied usage through specificity about metadata content, but lacks explicit guidance on when to use this vs sibling getNFTInfo or when not to use (e.g., for ERC-1155 tokens).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full transparency burden. It successfully discloses the data source (DefiLlama) and specific metrics included (chain distribution, 24h/7d change rates), which helps the agent understand the return data structure. It could be improved by mentioning whether data is cached/real-time or error behaviors for invalid protocols.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Extremely compact single sentence with parenthetical elaboration. Every element earns its place: the core action, data source context, and return value details. No redundancy or wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter read-only tool, the description adequately compensates for the missing output schema by detailing what metrics are returned (TVL amount, chain breakdown, time-based changes). It appropriately scopes the tool's capability without overpromising.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema has 100% description coverage with the protocol parameter clearly documented (including examples Aave, Uniswap). The main description doesn't add parameter semantics beyond what the schema already provides, warranting the baseline score for high-coverage schemas.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action (조회합니다/retrieves), resource (DeFi protocol TVL), data source (DefiLlama), and return details (chain distribution, 24h/7d rates). It effectively distinguishes from siblings like getTokenPrice (individual tokens) and getPortfolio (user holdings) by specifying protocol-level aggregate metrics.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
While the description clearly identifies the tool's function, it does not provide explicit guidance on when to use this versus similar data-retrieval siblings like getYieldRates or getTokenHolders. Usage is implied by the specificity of 'Protocol TVL' but lacks explicit when/when-not guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full disclosure burden. Successfully reveals critical behavioral traits: ParaSwap aggregation source, optimal routing algorithm, gas fee inclusion in calculation, and automatic ETH→WETH wrapping logic. Minor gap: doesn't explicitly state this is a read-only simulation (no transaction execution) or quote expiration behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Single efficient sentence with parenthetical elaboration. Main clause establishes core function; parentheses pack four distinct behavioral details (ParaSwap, optimal route, gas inclusion, ETH-WETH handling) without redundancy. Every element earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 100% schema coverage and no output schema, description adequately covers input requirements and calculation methodology. Mentions gas inclusion which hints at output composition. Minor deduction: lacks explicit description of return structure (expected fields like outputAmount, slippage, route details) that would complete the contract for a quote tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% (all 4 parameters fully documented with types and descriptions). The description mentions ETH→WETH auto-conversion which provides context for tokenIn/tokenOut parameters, but does not elaborate beyond what the schema already explicitly defines. Baseline 3 appropriate given schema completeness.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description uses specific verb '조회합니다' (queries/retrieves) with resource 'DEX 스왑 견적' (DEX swap quote). Distinguishes from siblings like getBridgeRoutes (bridge vs swap) and getTokenPrice (simple price lookup vs full quote with routes). Includes implementation specifics (ParaSwap-based) that clarify scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides implied usage context through 'DEX 스왑' terminology, distinguishing from bridging or simple price checks. However, lacks explicit guidance on when to choose this over getBridgeRoutes for cross-chain transfers or compareGas for gas estimation, and doesn't mention prerequisites like token approval requirements.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the disclosure burden effectively by specifying data sources vary by chain (Ethplorer vs Etherscan aggregation) and detailing the returned data structure (address, percentage, balance). Missing operational details like rate limits or caching behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Perfectly compact Korean description. Single sentence front-loaded with the action, followed by parenthetical details about data sources and return fields. Zero redundancy—every character earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite lacking an output schema, the description compensates by explicitly listing the return data fields (address/share/balance). Covers the essential behavioral context (data sources, limits) for a read-only query tool with well-documented parameters.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline 3 applies. The description does not add parameter-specific guidance beyond the schema (e.g., when to use symbol vs address), but the schema is self-sufficient with clear descriptions for all three parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb (조회합니다/retrieves) with clear resource (token holders) and scope (top holders). It distinguishes from siblings like getTokenInfo or getTokenPrice by specifying it returns holder rankings with address, share percentage, and balance data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Lacks explicit when-to-use guidance or named alternatives. However, the parenthetical specification of data sources (Ethplorer for Ethereum, Etherscan for others) and return fields (address/share/balance) implicitly signals to use this for distribution analysis rather than price queries or transfers.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![evmscope MCP server](https://glama.ai/mcp/servers/calintzy/evmscope/badges/card.svg)](https://glama.ai/mcp/servers/calintzy/evmscope)

Score Badge

Copy to your README.md:

[![evmscope MCP server](https://glama.ai/mcp/servers/calintzy/evmscope/badges/score.svg)](https://glama.ai/mcp/servers/calintzy/evmscope)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/calintzy/evmscope'

If you have feedback or need assistance with the MCP directory API, please join our Discord server