CoinGecko MCP Server

Overview Schema Related Servers Score Discussions

Server Quality Checklist

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

Latest release: v1.0.0
Disambiguation4/5
Most tools have distinct purposes targeting specific resources like coins, NFTs, exchanges, pools, or tokens, with clear descriptions that differentiate them. However, some overlap exists, such as multiple price-fetching tools (e.g., get_simple_price, get_id_simple_token_price, get_addresses_networks_simple_onchain_token_price) that could cause confusion in selection, though descriptions help clarify contexts like on-chain vs. API IDs.
Naming Consistency3/5
The naming follows a general get_ prefix pattern but is inconsistent in structure. Some tools use verb_noun (e.g., get_coins_markets), while others have long, descriptive names with underscores separating multiple nouns (e.g., get_addresses_networks_simple_onchain_token_price). There's no uniform convention, making it mixed but still readable due to the consistent use of underscores and the get_ prefix.
Tool Count2/5
With 50 tools, the count is excessive for a single server, even given the broad domain of cryptocurrency data. This many tools can overwhelm agents and increase cognitive load, as it includes highly specialized endpoints (e.g., for on-chain pools, NFTs, public treasury) that might be better organized into sub-servers or modules. It feels heavy and unwieldy for typical agent use.
Completeness5/5
The tool set is exceptionally comprehensive for the CoinGecko and GeckoTerminal APIs, covering a wide range of cryptocurrency data including coins, markets, NFTs, exchanges, on-chain analytics, and public treasury information. It provides extensive read operations with historical data, charts, searches, and metadata, leaving no obvious gaps for querying cryptocurrency information within the scope of these APIs.
Average 3.4/5 across 50 of 50 tools scored. Lowest: 2.6/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
Add a LICENSE file by following GitHub's guide. Once GitHub recognizes the license, the system will automatically detect it within a few hours.
If the license does not appear after some time, you can manually trigger a new scan using the MCP server admin interface.
MCP servers without a LICENSE cannot be installed.
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?
Annotations indicate readOnlyHint=true, which the description does not contradict. The description adds value by emphasizing the jq_filter parameter for performance optimization and response size reduction, which is useful behavioral context beyond the annotations. However, it lacks details on rate limits, error handling, or data freshness.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is poorly structured: it starts with a performance tip about jq_filter, then states the purpose, and includes a JSON schema snippet that belongs in an output schema field. This disrupts front-loading of key information and includes redundant elements, reducing clarity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 11 parameters, no output schema, and many siblings, the description is incomplete. It lacks information on response format, error cases, or usage examples. The embedded JSON schema is misplaced and does not compensate for the absence of a proper output schema.
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%, so the schema fully documents all 11 parameters. The description does not add any parameter-specific semantics beyond what the schema provides. It mentions jq_filter generically but repeats schema information. Baseline score of 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.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the tool 'allows you to query the prices of one or more coins by using their unique Coin API IDs', which provides a clear verb ('query') and resource ('prices of coins'). However, it does not differentiate this tool from its many siblings (like get_coins_markets or get_range_coins_market_chart), leaving ambiguity about when to use this specific tool versus others for price-related queries.
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 mentions using the jq_filter parameter for performance but does not specify contexts, prerequisites, or exclusions. With many sibling tools available, the lack of comparative guidance is a significant gap.
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?
Annotations indicate readOnlyHint=true, which the description aligns with by using 'query' (implying a read operation). The description adds minimal behavioral context beyond this, such as not mentioning rate limits, authentication needs, or response format. Since annotations cover the safety aspect, the bar is lower, but the description could have provided more operational details (e.g., query limits or data freshness).
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 purpose ('query multiple pools'). It avoids redundancy and wastes no words, though it could be slightly more structured (e.g., by explicitly listing key parameters). Overall, it's appropriately sized and clear.
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 tool's complexity (5 parameters, no output schema) and annotations (readOnlyHint only), the description is minimally adequate. It states the purpose but lacks details on output, error handling, or usage context. With no output schema, the description should ideally hint at return values, but it doesn't, leaving gaps in completeness for effective agent use.
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 60%, with three parameters (include, include_composition, include_volume_breakdown) having descriptions, while network and addresses lack descriptions. The description mentions 'network and pool address' but doesn't add meaning beyond the schema, such as format examples or constraints. Given the moderate coverage, the description doesn't fully compensate but doesn't worsen the gap, aligning with the baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the tool 'allows you to query multiple pools based on the provided network and pool address,' which clarifies the action (query) and resource (pools). However, it's somewhat vague about what 'query' entails (e.g., retrieving data vs. performing analysis) and doesn't explicitly differentiate from sibling tools like 'get_pools_networks_onchain_info' or 'get_search_onchain_pools,' leaving room for ambiguity.
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 mentions the parameters (network and addresses) but doesn't specify use cases, prerequisites, or exclusions. For example, it doesn't clarify if this is for batch queries or how it differs from other pool-related tools in the sibling list, offering minimal context for selection.
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?
Annotations indicate readOnlyHint=true, which the description aligns with by using 'query'. The description adds context about querying 'latest pools', implying a time-based or recency filter, but doesn't specify behavioral details like pagination handling (implied by the 'page' parameter), rate limits, or authentication needs. With annotations covering safety, it adds some value but lacks rich behavioral 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?
The description is a single, efficient sentence that front-loads the core purpose. It avoids unnecessary words, though it could be slightly more specific (e.g., clarify 'latest'). Every part earns its place, making it appropriately concise for the tool's complexity.
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 tool has annotations (readOnlyHint) and moderate schema coverage (75%), but no output schema, the description is minimally adequate. It covers the basic purpose but lacks details on output format, error handling, or how 'latest' is defined, leaving gaps in completeness for a query tool with multiple 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 description coverage is 75%, with clear descriptions for 'include', 'include_gt_community_data', and 'page', but 'network' lacks a description. The tool description mentions 'based on provided network', adding minimal context for the required parameter. It doesn't explain parameter interactions or provide examples, so it meets the baseline for high schema coverage without significant added value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the tool 'allows you to query all the latest pools based on provided network', which provides a verb ('query') and resource ('latest pools') with a network constraint. However, it doesn't differentiate from sibling tools like 'get_pools_networks_onchain_info' or 'get_pools_onchain_megafilter', leaving the scope vague regarding what makes these pools 'latest' versus other pool-related tools.
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 mentions querying 'latest pools' but doesn't specify criteria like time recency, newness, or how it differs from other pool-related tools in the sibling list, such as 'get_pools_networks_onchain_info' or 'get_search_onchain_pools', leaving the agent without explicit usage context.
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?
The annotations indicate readOnlyHint=true, which the description doesn't contradict. The description adds some behavioral context by emphasizing the 'jq_filter' parameter for performance optimization, which isn't covered by annotations. However, it lacks details on rate limits, error conditions, or data freshness that would be valuable for a complex financial data tool. With annotations covering safety, the description provides moderate additional value.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is poorly structured and not front-loaded. It starts with a performance tip about 'jq_filter' before stating the tool's purpose, which may confuse the agent. The inclusion of a full JSON output schema within the description is redundant and disrupts flow, as this should be handled separately in structured fields. The core purpose is buried, making it inefficient for quick understanding.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 10 parameters, no output schema, and complex financial data operations, the description is inadequate. It lacks explanation of return values (e.g., the structure of 'ohlcv_list'), error handling, or typical use cases. While annotations cover read-only safety, the description doesn't compensate for the missing output schema or provide sufficient context for effective agent use, 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 70%, with most parameters well-documented in the schema (e.g., 'aggregate', 'currency', 'limit'). The description doesn't add meaningful parameter semantics beyond what's in the schema, except for the general mention of 'token address' and 'network'. It fails to explain critical parameters like 'timeframe' or 'before_timestamp' in the description text. Given the high schema coverage, a baseline score of 3 is appropriate.
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's purpose: 'get the OHLCV chart (Open, High, Low, Close, Volume) of a token based on the provided token address on a network.' This specifies the verb ('get'), resource ('OHLCV chart'), and key inputs ('token address', 'network'). However, it doesn't explicitly differentiate from sibling tools like 'get_timeframe_pools_networks_onchain_ohlcv' which appears to serve a similar purpose for pools rather than 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?
The description provides minimal usage guidance. It includes a performance tip about using 'jq_filter' but doesn't specify when to use this tool versus alternatives (e.g., 'get_range_coins_ohlc' or 'get_timeframe_pools_networks_onchain_ohlcv' from the sibling list). No context about prerequisites, typical use cases, or exclusions is given, leaving the agent with insufficient guidance for tool selection.
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?
Annotations provide readOnlyHint=true, indicating a safe read operation. The description adds value by emphasizing performance optimization with 'jq_filter' and noting that omitting it should be done only if data isn't needed. However, it lacks details on rate limits, authentication needs, error conditions, or response format beyond the embedded schema. With annotations covering safety, the description adds some context but not rich behavioral traits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with performance advice and purpose, but it includes an embedded JSON output schema that duplicates information better placed in a structured output_schema field. This adds bulk without earning its place in the description text. The core description is concise, but the schema inclusion reduces structural efficiency.
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 9 parameters, 78% schema coverage, readOnlyHint annotation, and no output schema, the description is moderately complete. It states the purpose and performance tip but lacks output explanation (though schema is embedded), usage context, and error handling. For a tool with many parameters and no output schema, it should provide more guidance on response interpretation and 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 description coverage is 78%, which is high, so the baseline is 3. The description doesn't add meaning beyond what the schema provides for parameters like 'network' or 'addresses.' It mentions 'jq_filter' for response reduction but repeats schema info. No additional syntax, format, or usage examples are given for parameters, so it doesn't compensate for the 22% coverage gap.
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's purpose: 'get token price based on the provided token contract address on a network.' This is a specific verb+resource combination (get + token price) that distinguishes it from many siblings focused on pools, exchanges, or NFTs. However, it doesn't explicitly differentiate from similar tools like 'get_id_simple_token_price' or 'get_simple_price,' which might also retrieve token prices.
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 mentions using the 'jq_filter' parameter for performance but doesn't specify scenarios where this tool is preferred over siblings like 'get_id_simple_token_price' or 'get_simple_price.' There's no mention of prerequisites, exclusions, or comparative contexts.
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?
Annotations provide readOnlyHint=true, indicating a safe read operation. The description adds behavioral context by emphasizing performance optimization with 'jq_filter' and mentioning the response schema, which helps the agent understand output structure. However, it doesn't disclose other traits like rate limits, authentication needs, or pagination behavior (implied by 'page' parameter), leaving gaps despite annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is poorly structured: it starts with usage advice for 'jq_filter', then states the purpose, and includes a large, embedded JSON output schema that makes it verbose and hard to parse. The output schema should be in a separate field, not in the description. Sentences are useful but not front-loaded efficiently, reducing clarity.
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 tool's complexity (8 parameters, high schema coverage, readOnlyHint annotation, no output schema), the description is partially complete. It covers purpose and 'jq_filter' guidance but lacks details on error handling, rate limits, or full behavioral context. The embedded output schema compensates for no output schema field, but this is structurally inappropriate, leaving gaps in completeness.
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 high (88%), so the schema already documents most parameters well. The description adds value by strongly recommending 'jq_filter' for performance and referencing the output schema for field availability, but it doesn't provide additional semantic details beyond what the schema offers, such as examples for 'id' or 'coin_ids'. Baseline 3 is appropriate given the schema's coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states 'query exchange's tickers based on exchange's ID', which provides a verb ('query') and resource ('exchange's tickers'), but it's vague about what tickers are (e.g., cryptocurrency trading pairs) and doesn't differentiate from siblings like 'get_id_exchanges' or 'get_list_exchanges'. The purpose is clear but lacks specificity and sibling distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use the 'jq_filter' parameter ('always use... to reduce response size and improve performance') and when to omit it ('Only omit if you're sure you don't need the data'), which is clear context for usage. However, it doesn't mention when to use this tool versus alternatives like 'get_coins_markets' or other sibling tools, so it lacks full alternative guidance.
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?
Annotations provide readOnlyHint=true, indicating this is a safe read operation. The description adds useful behavioral context about performance optimization with jq_filter and mentions the endpoint's purpose, but doesn't disclose other important traits like rate limits, authentication needs, or what happens with invalid parameters. No contradiction with annotations exists.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is moderately concise but includes a performance tip that's somewhat front-loaded. The inclusion of a JSON output schema in the description text is redundant and adds unnecessary length, as this information should be in structured fields. The core purpose statement is clear but could be more streamlined.
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 tool's complexity (5 parameters, historical data query) and annotations covering safety, the description provides basic purpose and a performance tip. However, it lacks output explanation (no output schema provided), doesn't clarify error conditions, and offers minimal usage context. It's adequate but has clear gaps for a data retrieval 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 60%, with three parameters well-described (days, include_empty_intervals, jq_filter) and two undocumented (entity_id, coin_id). The description mentions Entity ID and Coin ID but doesn't add format or semantics beyond the schema. It emphasizes jq_filter usage, which aligns with schema documentation. Baseline 3 is appropriate given partial 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's purpose: 'query historical cryptocurrency holdings chart of public companies & governments by Entity ID and Coin ID'. This specifies the verb ('query'), resource ('historical cryptocurrency holdings chart'), and scope ('public companies & governments'). However, it doesn't explicitly distinguish this tool from sibling tools like 'get_transaction_history_public_treasury', which appears related but isn't directly contrasted.
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 some guidance about using the 'jq_filter' parameter for performance, but offers no explicit when-to-use or when-not-to-use instructions. It doesn't mention alternatives or prerequisites, and doesn't clarify how this tool differs from other public treasury or chart-related tools in the sibling list.
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?
Annotations declare readOnlyHint=true, which the description does not contradict (it describes a query operation). The description adds behavioral context by advising on performance optimization with 'jq_filter', but does not disclose other traits like rate limits, error handling, or authentication needs. With annotations covering safety, this earns a baseline score for adding some value.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is poorly structured: it starts with a usage tip, then states the purpose, and includes a large, redundant output schema that should be in a separate field. This front-loads non-essential information and wastes space, reducing clarity and efficiency.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (querying NFT data with performance considerations) and lack of output schema (the embedded schema is not properly leveraged), the description is incomplete. It fails to explain return values, error cases, or how the 'jq_filter' interacts with the response structure, leaving significant gaps for agent usage.
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 50% (only 'jq_filter' has a description). The description mentions 'jq_filter' for reducing response size, adding marginal semantics beyond the schema. However, it does not explain the 'id' parameter's format or constraints, leaving half the parameters inadequately documented. Baseline 3 is appropriate given partial compensation.
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's purpose: 'query all the NFT data (name, floor price, 24hr volume ...) based on the NFT collection ID'. It specifies the verb ('query'), resource ('NFT data'), and scope ('based on the NFT collection ID'), but does not explicitly differentiate from sibling tools like 'get_list_nfts' or 'get_markets_nfts', which prevents a score of 5.
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 provides implied usage guidance by emphasizing the 'jq_filter' parameter for performance and stating 'Only omit if you're sure you don't need the data'. However, it lacks explicit when-to-use rules, alternatives (e.g., vs. 'get_list_nfts'), or prerequisites, leaving gaps in agent decision-making.
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?
Annotations indicate readOnlyHint=true, confirming this is a safe read operation. The description adds some behavioral context by emphasizing performance optimization with jq_filter and noting the tool queries prices via contract addresses. However, it lacks details on rate limits, error handling, or data freshness (e.g., how 'last_updated_at' relates to real-time accuracy), which would be valuable given the financial nature of the data.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is moderately concise but poorly structured. It starts with a performance tip about jq_filter, which is useful but not front-loaded with the core purpose. The inclusion of a full JSON output schema within the description text is redundant and disrupts flow, as this could be better handled in a separate output schema field. Sentences are clear but could be more efficiently organized.
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 tool's complexity (9 parameters, financial data) and annotations (readOnlyHint only), the description is somewhat incomplete. It lacks output schema integration (though one is embedded, it's not structured), and doesn't cover error cases or data limitations. However, the high schema coverage and clear purpose provide a baseline, but more context on data sources or accuracy would enhance completeness.
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 high at 89%, so the schema already documents most parameters well. The description adds minimal value beyond the schema, only implicitly referencing 'contract_addresses' and 'vs_currencies' in the purpose statement. It doesn't explain parameter interactions or provide examples beyond the jq_filter note, which is covered in the schema's description for that parameter.
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's purpose: 'query one or more token prices using their token contract addresses.' This specifies the verb ('query'), resource ('token prices'), and key input ('token contract addresses'). However, it doesn't explicitly differentiate from sibling tools like 'get_simple_price' or 'get_coins_markets,' which might also retrieve price data, leaving some ambiguity about when to choose this specific tool.
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 minimal usage guidance. It advises to 'always use the `jq_filter` parameter to reduce response size and improve performance,' but offers no context on when to use this tool versus alternatives like 'get_simple_price' or other sibling tools. There's no mention of prerequisites, such as needing valid contract addresses or supported vs_currencies, which are required parameters.
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?
Annotations indicate readOnlyHint=true, so the agent knows this is a safe read operation. The description adds value by emphasizing performance optimization with 'jq_filter' and noting the data source ('GeckoTerminal'), but it doesn't disclose other behavioral traits like rate limits, pagination details (beyond the 'page' parameter in schema), or error handling. No contradiction with annotations exists.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is somewhat front-loaded with a performance tip, but it includes an embedded JSON output schema that duplicates structured data, adding unnecessary length. Sentences like 'Only omit if you're sure you don't need the data' are vague and don't earn their place, reducing efficiency.
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 annotations cover read-only safety and schema has moderate coverage, the description is minimally adequate. However, it lacks output schema integration (has_output_schema=false but includes JSON in description), doesn't explain return values or pagination fully, and misses sibling differentiation. For a query tool with 3 parameters, it's functional but has clear gaps.
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 67%, with 'jq_filter' well-documented in the schema but 'network' and 'page' lacking descriptions. The description doesn't add meaning beyond the schema: it mentions 'jq_filter' for performance but repeats schema info, and it doesn't clarify 'network' (e.g., expected format) or 'page' usage. Baseline is 3 due to moderate 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's purpose: 'query all the supported decentralized exchanges (DEXs) based on the provided network on GeckoTerminal.' It specifies the verb ('query'), resource ('supported decentralized exchanges'), and scope ('based on the provided network'), though it doesn't explicitly differentiate from sibling tools like 'get_onchain_networks' or 'get_exchanges_tickers' that might handle 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?
The description provides no guidance on when to use this tool versus alternatives. It mentions using 'jq_filter' for performance but doesn't explain when this tool is appropriate compared to sibling tools such as 'get_exchanges_tickers' or 'get_onchain_networks', leaving the agent without context for selection.
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?
The annotations provide 'readOnlyHint: true', indicating this is a safe read operation. The description adds some behavioral context by emphasizing the 'jq_filter' parameter for performance optimization and specifying that the tool returns OHLCV data for pools. However, it doesn't disclose other important traits like rate limits, authentication needs, error conditions, or pagination behavior (though 'limit' parameter hints at it). No contradiction with annotations exists.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is moderately concise but has structural issues. It front-loads a performance tip about 'jq_filter' before stating the core purpose, which may confuse initial understanding. The inclusion of a full JSON output schema within the description text is verbose and redundant if an output schema field exists (though context signals indicate no output schema, making this somewhat necessary but still cluttered). Sentences are clear but could be better organized.
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 tool's complexity (10 parameters, OHLCV data retrieval) and the absence of an output schema, the description is partially complete. It explains the core functionality and includes an embedded response schema, which helps. However, it lacks details on behavioral aspects like error handling, rate limits, and practical usage examples. With annotations covering read-only safety, the description adds some context but leaves gaps for a data-intensive 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 70%, with detailed descriptions for parameters like 'token', 'aggregate', and 'limit'. The description mentions 'pool address' and 'network' as key inputs but doesn't add significant semantic value beyond what the schema provides (e.g., it doesn't explain format examples or constraints for 'network' or 'pool_address'). Given the high schema coverage, a baseline score of 3 is appropriate as the description compensates minimally.
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's purpose: 'get the OHLCV chart (Open, High, Low, Close, Volume) of a pool based on the provided pool address on a network.' This specifies the verb ('get'), resource ('OHLCV chart'), and key parameters ('pool address', 'network'). However, it doesn't explicitly distinguish this tool from sibling tools like 'get_timeframe_tokens_networks_onchain_ohlcv' or 'get_range_coins_ohlc', which appear to serve similar OHLCV-related functions.
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 minimal usage guidance. It includes a performance tip about using 'jq_filter' to reduce response size, but offers no explicit guidance on when to use this tool versus alternatives (e.g., 'get_timeframe_tokens_networks_onchain_ohlcv' for tokens vs. pools, or 'get_range_coins_ohlc' for coins). There's no mention of prerequisites, typical use cases, or scenarios where this tool is preferred over 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?
The description adds some behavioral context beyond the annotations: it advises using 'jq_filter' for performance optimization and notes the endpoint queries top traders. However, the annotations already declare 'readOnlyHint: true,' so the agent knows it's a safe read operation. The description doesn't disclose additional traits like rate limits, authentication needs, or data freshness, resulting in a baseline score of 3 for adding minimal value over annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with a performance tip and purpose statement, but includes an extensive output schema that duplicates structured data. This adds unnecessary length without new value, as the schema could be referenced separately. The core description is concise, but the embedded schema reduces overall efficiency.
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 tool's complexity (6 parameters, read-only operation) and lack of an output schema (though one is embedded in the description), the description is moderately complete. It covers the purpose and a performance tip but lacks details on when to use, behavioral constraints, or parameter nuances. With annotations covering safety, it's adequate but has clear gaps in guidance and context.
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 67%, with four parameters documented (include_address_label, sort, traders, jq_filter) and two not (network_id, token_address). The description mentions 'token contract address on a network,' which hints at the required parameters but doesn't add detailed semantics beyond what the schema provides. Since coverage is moderate (>50%), the baseline is 3, as the description doesn't significantly compensate for gaps.
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's purpose: 'query top token traders based on the provided token contract address on a network.' This specifies the verb ('query'), resource ('top token traders'), and key inputs (token contract address, network). However, it doesn't explicitly differentiate from sibling tools like 'get_tokens_networks_onchain_top_holders' or 'get_tokens_networks_onchain_trades,' which reduces the score from a perfect 5.
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 usage guidance for the 'jq_filter' parameter ('always use... to reduce response size and improve performance'), but offers no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools or clarify the context for selecting this specific query over others, leaving the agent without comparative usage instructions.
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?
The description adds minimal behavioral context beyond the readOnlyHint annotation. It implies a read operation for querying data, which aligns with the annotation, but doesn't detail aspects like rate limits, error handling, or data freshness. The annotation covers safety, so the description meets a baseline by not contradicting it, but offers little extra insight.
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, clear sentence that efficiently conveys the core function without unnecessary details. It's front-loaded and avoids redundancy, though it could be slightly more structured by explicitly listing key parameters or use cases.
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 tool's moderate complexity (5 parameters, no output schema) and the readOnlyHint annotation, the description is minimally complete. It covers the basic purpose but lacks details on output format, error conditions, or advanced usage, leaving gaps that could hinder effective tool invocation by an AI agent.
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 description mentions 'token contract addresses' and 'network', aligning with the required parameters, but doesn't explain parameter formats or interactions. With 60% schema description coverage, the schema documents some parameters (e.g., include_composition), but the description adds no additional semantic value beyond what's implied, resulting in an adequate baseline score.
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's purpose: querying token data based on contract addresses on a network. It specifies the verb 'query' and the resource 'multiple tokens data', making the function understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_tokens_networks_onchain_info' or 'get_addresses_pools_networks_onchain_multi', which reduces precision.
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 mentions querying token data but doesn't specify scenarios, prerequisites, or exclusions. With many sibling tools available for token and network queries, the lack of comparative context leaves usage ambiguous.
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?
The annotations provide readOnlyHint=true, indicating this is a safe read operation. The description adds value by warning about large response sizes and recommending jq_filter for performance, which is useful behavioral context not covered by annotations. However, it doesn't disclose other traits like rate limits, authentication needs, or pagination behavior. No contradiction with annotations exists.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is poorly structured and verbose. It starts with a performance tip about jq_filter, then states the purpose, and includes a full JSON output schema that duplicates information better placed elsewhere. The output schema bloats the description unnecessarily, and the purpose statement is buried. Sentences don't earn their place efficiently, making it harder to scan.
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 tool's complexity (5 parameters, read-only operation) and lack of output schema in structured fields, the description includes an output schema, which helps. However, it fails to explain key contextual aspects like the meaning of 'top 30' (is it fixed? ranked by what?), how gainers/losers are calculated, or error conditions. The jq_filter advice is useful but doesn't compensate for other gaps.
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%, so the schema fully documents all 5 parameters. The description doesn't add any parameter-specific semantics beyond what's in the schema (e.g., it mentions 'time duration' but doesn't clarify the 'duration' parameter's enum values or interactions). With high schema coverage, the baseline score of 3 is appropriate as the description provides no extra parameter insights.
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's purpose: 'query the top 30 coins with largest price gain and loss by a specific time duration.' This specifies the verb ('query'), resource ('top 30 coins'), and scope ('largest price gain and loss by time duration'). However, it doesn't explicitly differentiate from sibling tools like 'get_coins_markets' or 'get_simple_price' that might also provide coin price 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?
The description provides some usage guidance by recommending to 'always use the jq_filter parameter to reduce response size and improve performance,' which implies this tool returns large datasets. However, it doesn't specify when to use this tool versus alternatives (e.g., vs. 'get_coins_markets' for broader market data) or mention any prerequisites beyond the required 'vs_currency' parameter. The guidance is practical but incomplete for tool selection.
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?
The description adds minimal behavioral context beyond the readOnlyHint annotation. It mentions 'top pools' which implies ranking/sorting, but doesn't explain ranking criteria, pagination behavior, or what 'top' means. The annotations already declare readOnlyHint=true, so the agent knows it's safe. The description doesn't contradict annotations, but adds only basic operational context.
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 gets straight to the point. It uses bold formatting effectively to highlight key elements. There's no wasted verbiage or unnecessary preamble. However, it could be slightly more structured by explicitly separating purpose from constraints or usage context.
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 read-only query tool with good schema coverage but no output schema, the description is minimally adequate. It states what the tool does but lacks important context about result format, pagination behavior, error conditions, or how it differs from similar pool/token tools. The absence of output schema means the description should ideally provide more guidance about what to expect in return.
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 67% schema description coverage, the schema already documents most parameters well. The description mentions 'token contract address' and 'network' which map to required parameters, but adds no additional semantic context about format, validation, or relationships between parameters. It doesn't explain what 'top pools' means in relation to the sort parameter or how results are filtered/ranked.
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's purpose: 'query top pools based on the provided token contract address on a network'. It specifies the verb ('query'), resource ('top pools'), and key inputs (token address, network). However, it doesn't explicitly differentiate from sibling tools like 'get_pools_networks_onchain_info' or 'get_search_onchain_pools', which appear to have overlapping functionality.
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. With many sibling tools related to pools, tokens, and networks, there's no indication of when this specific 'top pools' query is appropriate versus other pool or token information tools. No prerequisites, exclusions, or comparative context is 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?
Annotations provide readOnlyHint=true, indicating this is a safe read operation. The description adds useful behavioral context: it emphasizes performance optimization through jq_filter and mentions the response includes holders with specific fields (address, amount, etc.) via the embedded schema. However, it doesn't disclose rate limits, authentication needs, or data freshness details (beyond last_updated_at in schema). The description doesn't contradict annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is poorly structured: it starts with a performance tip about jq_filter before stating the core purpose, and includes a full JSON output schema inline, which is redundant and verbose. The output schema should be in a separate field, not in the description. Sentences are useful but not front-loaded, and the embedded schema adds unnecessary length.
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 complexity (4 parameters, read-only operation) and lack of output schema in structured fields, the description includes an output schema, which helps. However, it's embedded in the description rather than provided separately, and key contextual details like rate limits, error handling, or pagination are missing. The annotations cover safety, but more behavioral context is needed for full completeness.
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 50% (2 of 4 parameters have descriptions). The description doesn't add meaningful parameter semantics beyond what's in the schema: it mentions jq_filter but repeats schema guidance, and doesn't explain network/address parameters. With moderate schema coverage, the baseline is 3, as the description doesn't compensate for the undocumented parameters (network, address).
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's purpose: 'query top token holders based on the provided token contract address on a network'. This is a specific verb+resource combination that distinguishes it from most siblings (e.g., get_tokens_networks_onchain_info, get_tokens_networks_onchain_pools). However, it doesn't explicitly differentiate from get_tokens_networks_onchain_holders_chart, which appears related but not identical.
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 provides some usage guidance by emphasizing the jq_filter parameter for performance and stating 'Only omit if you're sure you don't need the data.' This implies a recommended practice but doesn't specify when to use this tool versus alternatives like get_tokens_networks_onchain_holders_chart or other holder-related tools. No explicit when-not-to-use or prerequisite information is 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?
The annotation provides readOnlyHint=true, indicating this is a safe read operation. The description adds that it searches 'documentation for how to use the client to interact with the API,' which provides useful context about what kind of information is returned. However, it doesn't disclose behavioral traits like pagination, rate limits, authentication needs, or what happens with no results. With annotations covering the safety aspect, a 3 is appropriate as the description adds some value but not rich behavioral context.
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, clear sentence that efficiently states the tool's purpose. It's appropriately sized for a search tool with three parameters. There's no wasted verbiage or unnecessary elaboration. It could be slightly more structured by explicitly mentioning the parameters, but as a standalone sentence it's well-formed.
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 search tool with 3 parameters, 100% schema coverage, and readOnlyHint annotation, the description is minimally adequate. It explains what kind of content is searched (documentation about API client usage), which is valuable context. However, without an output schema, the description doesn't explain what format results come in or what happens with empty results. The description covers the basics but leaves gaps about result format and edge cases.
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 all parameters well-documented in the schema. The description doesn't add any parameter-specific information beyond what's in the schema. It mentions 'documentation' which relates to the query parameter, but doesn't provide additional syntax, format, or usage details. Baseline 3 is correct when the schema does the heavy lifting.
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's purpose: 'Search for documentation for how to use the client to interact with the API.' It specifies the verb ('search') and resource ('documentation'), and the scope ('how to use the client to interact with the API') is reasonably specific. However, it doesn't explicitly differentiate from sibling tools, which appear to be cryptocurrency/blockchain data queries rather than documentation search tools.
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 doesn't mention prerequisites, constraints, or suggest other tools for related tasks. The sibling tools are all cryptocurrency data queries, so this documentation search tool is clearly distinct, but the description doesn't help the agent understand when documentation search is appropriate versus data queries.
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?
The annotation provides readOnlyHint=true, indicating this is a safe read operation. The description adds minimal behavioral context beyond this - it mentions 'query' and 'filters' but doesn't disclose pagination behavior, rate limits, authentication needs, or what happens when no filters are applied. It doesn't contradict the annotation, but adds little value beyond it.
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 essential information: querying pools with filters across all networks. There's no wasted verbiage or unnecessary elaboration - every word 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 complex filtering tool with 28 parameters and no output schema, the description is minimal. While annotations cover safety (readOnlyHint), the description doesn't address what the tool returns, pagination behavior, or typical use cases. Given the complexity and lack of output schema, more context would be helpful for an agent to use this effectively.
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 input schema already thoroughly documents all 28 parameters. The description mentions 'various filters' but provides no additional parameter semantics beyond what's in the schema. This meets the baseline for high schema coverage where the description doesn't need to compensate.
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's purpose: 'query pools based on various filters across all networks on GeckoTerminal'. It specifies the verb ('query'), resource ('pools'), and scope ('all networks'), though it doesn't explicitly differentiate from sibling tools like 'get_pools_networks_onchain_info' or 'get_search_onchain_pools'.
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. With many sibling tools for querying pools (e.g., 'get_pools_networks_onchain_info', 'get_search_onchain_pools'), there's no indication of when this 'megafilter' tool is preferred over simpler or more specific pool querying tools.
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?
Annotations provide readOnlyHint=true, indicating a safe read operation. The description adds performance guidance about jq_filter usage and includes a detailed response schema, which helps agents understand output structure. However, it doesn't mention pagination behavior (implied by 'page' parameter), rate limits, or authentication requirements beyond what annotations cover.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with usage guidance, but includes a lengthy response schema that duplicates what could be in an output schema field. The first three sentences are efficient, but the schema inclusion makes it verbose. Structure could be improved by separating usage notes from technical schema details.
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 5 parameters with full schema coverage, readOnlyHint annotation, and no output schema, the description provides good context. It includes a detailed response schema (compensating for no output schema), usage guidance, and references external documentation. However, it lacks information about pagination limits or error conditions.
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%, so parameters are well-documented in the input schema. The description emphasizes jq_filter importance and references the output schema for field availability, adding some value. However, it doesn't explain parameter interactions (e.g., how 'query' and 'include' work together) or provide examples beyond jq_filter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states 'search for pools on a network', which provides a basic verb+resource combination. However, it's vague about search criteria and doesn't distinguish this tool from sibling pool-related tools like 'get_pools_networks_onchain_info' or 'get_pools_onchain_megafilter'. The purpose is understandable but lacks specificity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear guidance on when to use the jq_filter parameter ('always use... to reduce response size and improve performance') and when to omit it ('only omit if you're sure you don't need the data'). This gives practical usage advice, though it doesn't specify when to use this tool versus alternative pool search tools among 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?
Annotations provide readOnlyHint=true, indicating this is a safe read operation. The description adds behavioral context by emphasizing performance optimization with 'jq_filter' and noting it queries 'all' asset platforms, which suggests potentially large data volumes. However, it doesn't disclose rate limits, authentication needs, or pagination behavior. With annotations covering safety, the description adds some value but not rich behavioral details.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with usage advice but includes a verbose output schema in the description text, which is redundant since there's no output schema in context signals. The first two sentences are efficient, but the schema duplication adds unnecessary length. It could be more concise by omitting the embedded schema or integrating it better.
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 tool has read-only annotations, 2 parameters with full schema coverage, and no output schema, the description is moderately complete. It covers purpose and parameter guidance but lacks details on response format (though implied by the embedded schema), error handling, or integration with siblings. For a query tool with good annotations, it's adequate but has gaps in contextual richness.
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 description coverage is 100%, so the schema fully documents both parameters. The description adds semantic context by strongly recommending 'jq_filter' for performance and explaining its purpose ('reduce the response size'), which goes beyond the schema's technical description. It also implies the 'filter' parameter's use case through the enum 'nft', though not explicitly. This compensates well, earning above the baseline 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 states 'query all the asset platforms on CoinGecko', which is a clear verb+resource combination. It specifies the scope ('all the asset platforms') but doesn't explicitly differentiate from sibling tools like 'get_onchain_networks' or 'get_networks_onchain_dexes', which might have overlapping functionality. The purpose is clear but lacks sibling differentiation.
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 provides guidance on when to use the 'jq_filter' parameter ('always use... to reduce response size and improve performance') and when to omit it ('Only omit if you're sure you don't need the data'), which implies usage context. However, it doesn't specify when to use this tool versus alternatives among the many sibling tools (e.g., for asset platforms vs. networks or other data types), leaving the agent to infer based on tool 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?
The annotations indicate readOnlyHint=true, which the description aligns with by describing a query operation (no contradiction). The description adds behavioral context by highlighting performance considerations with 'jq_filter' and specifying that it returns data 'at a given date,' which clarifies the snapshot nature. However, it doesn't disclose other traits like rate limits, error conditions, or pagination, leaving gaps despite the annotation covering safety.
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 relatively concise, with two sentences upfront about 'jq_filter' usage and the core purpose, followed by an output schema. The front-loaded sentences are efficient, but the inclusion of the full output schema in the description text adds bulk that might be redundant if structured elsewhere. Overall, it's well-structured but could be more streamlined by omitting the schema duplication.
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 tool's complexity (historical data query with 4 params), annotations cover read-only safety, and schema coverage is high (75%), the description is moderately complete. It explains the purpose and a key performance tip but lacks details on output format (though the embedded schema helps), error handling, or comparisons to siblings. The output schema in the description compensates partially, but it's verbose and might be better handled separately.
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 75%, with parameters 'id' and 'date' well-documented in the schema (e.g., date format 'YYYY-MM-DD'), and 'jq_filter' has a detailed schema description. The description adds minimal param semantics beyond the schema, only emphasizing 'jq_filter' for performance. It doesn't explain 'localization' or provide examples beyond what's in the schema, so it meets the baseline for high schema coverage without significant added 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's purpose: 'query the historical data (price, market cap, 24hrs volume, ...) at a given date for a coin based on a particular coin ID.' This specifies the verb ('query'), resource ('historical data'), and scope ('coin ID', 'date'), making it easy to understand. However, it doesn't explicitly differentiate from sibling tools like 'get_range_coins_market_chart' or 'get_coins_markets', which might also involve historical or market 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?
The description provides some usage guidance by emphasizing the importance of the 'jq_filter' parameter to reduce response size and improve performance, with a note to omit it only if unnecessary. This implies a best practice for when to use this parameter. However, it lacks explicit guidance on when to choose this tool over alternatives (e.g., vs. 'get_coins_markets' for current data or 'get_range_coins_market_chart' for time series), and no prerequisites or exclusions are 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?
Annotations declare readOnlyHint=true, which the description doesn't contradict. The description adds useful behavioral context by emphasizing performance optimization through jq_filter usage and warning about response size. However, it doesn't disclose other behavioral traits like rate limits, authentication needs, or pagination behavior that might be relevant for API tools.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is reasonably concise with three sentences, but the structure is somewhat awkward. It starts with usage advice about jq_filter before stating the core purpose, and includes an output schema snippet that belongs in structured fields rather than the description. The sentences earn their place, but the ordering could be more logical.
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 tool's simplicity (one optional parameter, read-only operation with annotations), the description is mostly adequate. It explains the purpose and provides important usage advice. However, it lacks information about response format details (though it references an output schema in the description text), and doesn't address potential limitations or error conditions that might be relevant for API consumption.
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 description coverage, the input schema fully documents the single parameter. The description adds value by strongly advocating for jq_filter usage and explaining why (performance, response size), which provides semantic context beyond the schema's technical documentation. For a tool with only one optional parameter, this is good supplemental guidance.
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's purpose: 'query all the coins categories on CoinGecko'. This is a specific verb ('query') and resource ('coins categories'), making the function unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'get_onchain_categories' or 'get_pools_onchain_categories', which might have overlapping domains.
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 provides some usage guidance by strongly recommending the use of the 'jq_filter' parameter to reduce response size and improve performance, and suggests omitting it only when certain. However, it doesn't explain when to use this tool versus alternatives (e.g., other category-related tools in the sibling list) or provide context about when this query is appropriate versus other data retrieval methods.
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?
Annotations provide readOnlyHint=true, which the description doesn't contradict. The description adds valuable behavioral context beyond annotations: it emphasizes performance optimization through jq_filter usage, warns about potentially large response sizes, and describes the data scope (floor price, market cap, volume, market data). It doesn't mention rate limits, authentication needs, or pagination behavior, but with annotations covering safety, this adds meaningful context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness2/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is poorly structured: it starts with a usage tip about jq_filter, then states the purpose, and includes a full output schema that belongs in a separate field. The output schema duplication makes it verbose and unfocused, with sentences that don't efficiently earn their place in the core description.
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 tool's complexity (5 parameters, rich data), annotations cover read-only safety, but there's no output schema in structured fields (the description embeds one). The description provides purpose and some behavioral context, but lacks details on pagination defaults, error handling, or data freshness. It's adequate but has gaps for a data query tool with multiple 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 description coverage is 100%, so the schema fully documents all 5 parameters. The description mentions jq_filter specifically for performance, adding some practical guidance beyond the schema's technical documentation. However, it doesn't explain the semantics of other parameters like 'order' or 'asset_platform_id' beyond what the schema provides, meeting the baseline 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?
The description clearly states the tool's purpose: 'query all the supported NFT collections with floor price, market cap, volume and market related data on CoinGecko'. It specifies the verb ('query'), resource ('NFT collections'), and scope ('all supported'), but doesn't explicitly differentiate from sibling tools like 'get_list_nfts' or 'get_nfts_market_chart', which appear related.
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 provides some usage guidance by recommending 'always use the `jq_filter` parameter to reduce response size and improve performance', with a conditional 'Only omit if you're sure you don't need the data'. However, it doesn't specify when to use this tool versus alternatives like 'get_list_nfts' or 'get_nfts_market_chart' from the sibling list, leaving the context implied rather than explicit.
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?
Annotations provide readOnlyHint=true, indicating a safe read operation. The description adds behavioral context by stating it queries 'the last 300 trades in the past 24 hours', which sets a limit and time window not covered by annotations. However, it doesn't disclose other traits like rate limits, authentication needs, or error handling, so it adds some value but not rich behavioral details beyond the annotations.
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 front-loaded with usage advice and purpose, using two sentences plus a note on response schema. It avoids unnecessary fluff, but the inclusion of a full JSON output schema in the description text adds bulk that could be streamlined if an output schema field were used instead, slightly reducing efficiency.
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 tool has annotations (readOnlyHint) and a detailed input schema, the description covers the core purpose and a key parameter tip. However, with no output schema provided separately (though embedded in the description), it lacks explicit return value explanation, and for a tool with 5 parameters and moderate schema coverage, it should do more to clarify usage context and parameter interactions 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?
Schema description coverage is 60%, with parameters like 'token' and 'trade_volume_in_usd_greater_than' having descriptions in the schema. The description mentions using 'jq_filter' to reduce response size, adding practical advice beyond the schema. However, it doesn't explain the semantics of 'network' or 'pool_address' (which are required but undocumented in the description), so it partially compensates but doesn't fully address the coverage gap.
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 states 'query the last 300 trades in the past 24 hours based on the provided pool address', which clearly specifies the action (query), resource (trades), and scope (last 300 trades in 24 hours for a pool). However, it doesn't explicitly differentiate from sibling tools like 'get_tokens_networks_onchain_trades' or 'get_pools_networks_onchain_info', which might handle similar data, so it misses full sibling distinction.
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 provides some guidance by emphasizing to 'always use the `jq_filter` parameter to reduce response size and improve performance', which implies a best practice for usage. However, it doesn't specify when to use this tool versus alternatives (e.g., compared to 'get_tokens_networks_onchain_trades' for token-specific trades or 'get_pools_networks_onchain_info' for pool details), leaving usage context implied rather than explicit.
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?
Annotations provide readOnlyHint=true, indicating a safe read operation. The description adds value by mentioning performance considerations with 'jq_filter' and specifying the scope ('all networks'), which are useful behavioral traits not covered by annotations. However, it doesn't disclose other potential behaviors like rate limits, error handling, or data freshness, keeping it at an adequate but not comprehensive level.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is relatively concise with two main sentences, but it includes a large, embedded JSON output schema that disrupts flow and isn't part of the descriptive text. The first part is front-loaded with usage advice, but the schema inclusion adds unnecessary bulk, reducing overall efficiency. It could be more streamlined by referencing the schema separately.
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 complexity (querying trending pools across networks) and the presence of annotations (readOnlyHint) and a detailed input schema, the description is mostly complete. It explains the purpose and offers performance tips. However, it lacks an output schema (the embedded JSON is in the description but not structured as an output schema field), so the agent must infer return values from the text, slightly reducing completeness.
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%, so the input schema fully documents the three parameters ('include', 'pools', 'jq_filter'). The description doesn't add any parameter-specific semantics beyond what's in the schema, such as explaining 'include' options in more detail or giving examples for 'pools'. Thus, it meets the baseline for high schema coverage without extra 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's purpose: 'query all the trending search pools across all networks on GeckoTerminal'. It specifies the verb ('query') and resource ('trending search pools'), making it understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_search_trending' or 'get_pools_onchain_megafilter', which might offer similar functionality, so it doesn't reach the highest score.
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 provides some usage guidance by recommending the use of 'jq_filter' to reduce response size and improve performance, with a note to omit it only if unnecessary. This implies a context for performance optimization. However, it lacks explicit guidance on when to use this tool versus alternatives (e.g., compared to 'get_search_trending' or other pool-related tools), leaving the agent to infer usage from the purpose 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?
Annotations provide 'readOnlyHint: true', indicating this is a safe read operation. The description adds value by emphasizing performance considerations with 'jq_filter' and noting the response is in BTC, which aren't covered by annotations. However, it doesn't disclose other behavioral traits like rate limits, error handling, or data freshness, which could be important for a query tool. No contradiction with annotations exists, as the description's 'query' aligns with read-only behavior.
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 relatively concise, with two main parts: usage advice for 'jq_filter' and the core purpose statement. However, it includes an unnecessary output schema snippet that duplicates information better handled in a structured field, and the formatting with markdown and code blocks adds clutter. The key information is front-loaded, but the structure could be cleaner by removing redundant schema details.
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 tool's complexity (querying historical data with multiple parameters), annotations cover read-only safety, and schema coverage is high at 75%. The description adds some context like BTC units and performance tips, but lacks output details (no output schema provided) and doesn't fully explain behavioral aspects like data format or limitations. It's adequate for basic use but leaves gaps in fully guiding the agent, especially without output schema support.
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 75%, with parameters 'id', 'from', and 'to' having descriptions in the schema (e.g., 'starting date in UNIX timestamp'), while 'jq_filter' is well-documented in both schema and description. The description adds minimal semantic value beyond the schema, mainly reiterating the date range aspect and advising on 'jq_filter' usage. Given the high schema coverage, the baseline score of 3 is appropriate, as the description doesn't significantly enhance parameter understanding beyond what's already structured.
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's purpose: 'query the historical volume chart data in BTC by specifying date range in UNIX based on exchange's ID'. This specifies the verb ('query'), resource ('historical volume chart data'), and key constraints (BTC units, date range in UNIX, exchange ID). However, it doesn't explicitly differentiate from sibling tools like 'get_range_coins_market_chart' or 'get_exchanges_tickers', which might also involve exchange or chart data, leaving some ambiguity about when this specific tool is uniquely appropriate.
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 provides implied usage guidance: it mentions using the 'jq_filter' parameter to reduce response size and improve performance, and advises omitting it only if sure the data isn't needed. This gives some context on parameter usage. However, it lacks explicit guidance on when to use this tool versus alternatives (e.g., compared to sibling tools like 'get_exchanges_tickers' or 'get_range_coins_market_chart'), and doesn't mention prerequisites or exclusions, leaving the agent to infer based on the purpose 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?
The annotations provide readOnlyHint=true, indicating this is a safe read operation. The description adds performance guidance about using jq_filter to reduce response size, which is useful behavioral context beyond what annotations provide. However, it doesn't mention other behavioral aspects like rate limits, pagination behavior (implied by page/per_page parameters), 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.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with important usage guidance about jq_filter, followed by the core purpose statement. However, it includes a full response schema in the description text that duplicates what should be in an output schema field, making it unnecessarily long and violating the principle that 'every sentence should earn its place.' The performance guidance and purpose statement are concise, but the embedded schema adds bulk.
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 read-only tool with 14 parameters and no output schema, the description provides adequate context about what data is returned and performance considerations. However, it lacks information about response format details, pagination behavior, rate limits, or error conditions that would be helpful given the tool's complexity. The embedded response schema partially compensates for the missing output schema but isn't a proper substitute.
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%, so the schema already fully documents all 14 parameters. The description doesn't add any parameter-specific information beyond what's in the schema. It mentions jq_filter in a general performance context but doesn't provide additional semantic meaning for any parameters. Baseline 3 is appropriate when schema coverage is complete.
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 states the tool 'allows you to query all the supported coins with price, market cap, volume and market related data', which is a clear verb ('query') and resource ('coins') combination. It specifies the type of data returned (price, market cap, volume, market data), but doesn't explicitly differentiate from sibling tools like 'get_simple_price' or 'get_coins_top_gainers_losers'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear guidance on when to use the jq_filter parameter ('always use...to reduce response size and improve performance') and when to omit it ('Only omit if you're sure you don't need the data'). However, it doesn't provide guidance on when to use this tool versus alternative tools for coin market data among the many sibling tools listed.
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?
Annotations provide readOnlyHint=true, indicating this is a safe read operation. The description adds behavioral context about performance optimization through jq_filter usage and clarifies the scope of data returned (all supported NFTs with specific fields). However, it doesn't mention pagination behavior, rate limits, authentication needs, or error conditions beyond what annotations cover.
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 appropriately sized with three sentences that each serve a purpose: performance guidance, conditional omission advice, and core functionality explanation. It's front-loaded with the most important usage recommendation. The inclusion of the response schema in the description text adds length but provides necessary context since there's no separate output schema.
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 moderate complexity (4 parameters, read-only operation) and 100% schema coverage, the description is reasonably complete. It includes the response schema directly in the description to compensate for the lack of a separate output schema. The performance guidance and field specification provide adequate context for an agent to use the tool effectively, though sibling tool differentiation is lacking.
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 all parameters well-documented in the input schema. The description adds value by emphasizing the importance of the jq_filter parameter for performance and providing a brief example of its usage. However, it doesn't explain the semantics of other parameters like 'order' enum values or 'per_page' range beyond what's already in the 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?
The description clearly states the tool's purpose: 'query all supported NFTs with ID, contract address, name, asset platform ID and symbol on CoinGecko'. It specifies the verb 'query' and resource 'NFTs', listing the specific fields returned. However, it doesn't explicitly differentiate from sibling tools like 'get_id_nfts' or 'get_markets_nfts', which might offer different NFT-related functionality.
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 provides implied usage guidance by strongly recommending use of the 'jq_filter' parameter to reduce response size and improve performance, with a conditional 'Only omit if you're sure you don't need the data'. However, it doesn't explicitly state when to use this tool versus alternatives among the many NFT-related sibling tools, nor does it mention 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?
Annotations provide readOnlyHint=true, indicating this is a safe read operation. The description adds useful behavioral context about performance optimization with jq_filter and mentions pagination through the 'page' parameter (implied by the schema). However, it doesn't disclose other behavioral traits like rate limits, authentication needs, or response format details beyond the embedded schema, which would be helpful given no output schema is provided.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized but not optimally structured. It starts with a performance tip about jq_filter before stating the core purpose, which could be front-loaded better. The embedded JSON schema adds length but is necessary due to the lack of an output schema. Some sentences like 'Only omit if you're sure you don't need the data' are somewhat redundant with the first sentence.
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 (2 optional parameters), 100% schema coverage, and readOnlyHint annotation, the description is mostly complete. It includes an embedded output schema to compensate for the missing output schema field, and it adds performance guidance. However, it could better address sibling differentiation and more explicit behavioral context to be fully comprehensive.
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 description coverage is 100%, so the schema fully documents both parameters. The description adds value by emphasizing the importance of 'jq_filter' for performance and providing a usage tip, and it references the output schema in the description for field availability. This goes beyond the schema's technical documentation, though it doesn't add deep semantic context for the 'page' parameter.
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's purpose: 'query all the supported networks on GeckoTerminal' which is a specific verb+resource combination. However, it doesn't explicitly differentiate from sibling tools like 'get_asset_platforms' or 'get_network_networks_onchain_new_pools' that might also relate to networks, leaving some ambiguity about when to choose this specific tool.
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 provides some usage guidance by emphasizing the importance of using the 'jq_filter' parameter for performance and advising to omit it only when unnecessary. However, it lacks explicit context about when to use this tool versus alternatives like 'get_asset_platforms' or other network-related siblings, leaving the agent to infer usage from the purpose statement alone.
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?
Annotations provide readOnlyHint=true, indicating a safe read operation. The description adds valuable behavioral context beyond this: it strongly recommends using 'jq_filter' to reduce response size and improve performance, which is a practical constraint not covered by annotations. It doesn't mention rate limits or authentication needs, but the performance advice is helpful.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with performance advice and purpose, but it includes a large, embedded JSON output schema that belongs in a structured field, not the description text. This makes it overly verbose and poorly structured, though the initial sentences are concise and relevant.
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 tool's complexity (5 parameters, 80% schema coverage, read-only annotation), the description is partially complete. It covers purpose and performance tips but lacks output details (no output schema provided) and doesn't explain pagination or error handling. The embedded JSON schema in the description is redundant and should be in a proper output schema field.
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 80%, so the schema already documents most parameters well (e.g., 'include' with available values, 'page' with default, 'sort' with enum). The description adds no additional parameter semantics beyond what's in the schema, but it emphasizes 'jq_filter' for performance, which is partially covered in the schema's description. 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 states 'query all the pools based on the provided category ID', which clearly specifies the verb ('query') and resource ('pools') with the key constraint ('category ID'). It distinguishes from siblings like 'get_pools_onchain_megafilter' or 'get_pools_networks_onchain_info' by focusing on category-based filtering, 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 Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides implied usage guidance by emphasizing the 'jq_filter' parameter for performance and stating to 'omit if you're sure you don't need the data', but it doesn't explicitly say when to use this tool versus alternatives (e.g., 'get_pools_onchain_megafilter' for broader filtering). No exclusions or prerequisites are 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?
Annotations indicate readOnlyHint=true, which the description aligns with by describing a data retrieval operation ('get'). The description adds some behavioral context: it emphasizes performance considerations with 'jq_filter' and mentions the response includes arrays of prices, market caps, and volumes. However, it doesn't disclose other traits like rate limits, authentication needs, or data freshness. With annotations covering safety, a 3 is appropriate as the description adds moderate value beyond annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is somewhat front-loaded with the 'jq_filter' recommendation, but it includes an embedded JSON output schema that is redundant with the context signals (output schema is false in signals, but description includes one). This adds unnecessary length. The core purpose is stated clearly, but the structure could be more streamlined by removing the schema duplication or integrating it better.
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 tool's complexity (7 parameters, 4 required) and the presence of annotations (readOnlyHint) but no output schema in context signals, the description is moderately complete. It explains the purpose, gives usage tips, and includes an output schema in the description text, which compensates for the missing output schema in signals. However, it lacks details on error handling, data granularity, or how to interpret the response arrays, leaving some gaps for an AI agent.
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 high at 86%, with detailed descriptions for parameters like 'from', 'to', 'vs_currency', 'interval', 'precision', and 'jq_filter'. The description doesn't add significant semantic details beyond the schema, except for strongly recommending 'jq_filter' for performance. Given the high schema coverage, the baseline is 3, as the schema does most of the parameter documentation work.
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's purpose: 'get the historical chart data of a coin within certain time range in UNIX along with price, market cap and 24hr volume based on particular coin ID.' It specifies the verb ('get'), resource ('historical chart data'), and key data fields. However, it doesn't explicitly differentiate from sibling tools like 'get_range_coins_ohlc' or 'get_range_contract_coins_market_chart,' which appear to serve similar chart/data retrieval functions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear usage guidance: it strongly recommends using the 'jq_filter' parameter to reduce response size and improve performance, and advises omitting it only if the data is definitely not needed. This gives practical advice on when to use a specific parameter. However, it doesn't specify when to use this tool versus alternative tools for similar data (e.g., 'get_range_coins_ohlc'), nor does it mention prerequisites or exclusions.
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 annotations provide readOnlyHint=true, indicating this is a safe read operation. The description adds valuable behavioral context beyond annotations: it emphasizes performance optimization with jq_filter, warns about response size, and clarifies the data type (OHLC chart). However, it doesn't mention rate limits, authentication needs, or error handling. Given the annotations cover safety, the description adds useful operational advice, earning a score above baseline.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is structured with a performance tip first, followed by the core purpose. However, it includes a redundant 'Response Schema' section that duplicates output information without adding value, as there's no output schema provided. The text could be more concise by removing this duplication and focusing solely on the tool's functionality and usage advice.
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 complexity (6 parameters, OHLC data), the description covers the basic purpose and performance tips but lacks details on output format (only hinted via the redundant schema snippet), error cases, or integration with sibling tools. With no output schema and rich annotations (readOnlyHint), the description is adequate but leaves gaps in fully preparing an agent for effective use, especially regarding response 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?
The input schema has high description coverage (83%), with clear documentation for parameters like 'from', 'to', 'vs_currency', and 'jq_filter'. The description doesn't add significant semantic details beyond the schema, except implicitly reinforcing the use of 'jq_filter'. Since the schema does most of the work, the baseline score of 3 is appropriate, as the description provides minimal extra parameter insight.
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's purpose: 'get the OHLC chart (Open, High, Low, Close) of a coin within a range of timestamp based on particular coin ID.' This specifies the verb ('get'), resource ('OHLC chart'), and scope ('coin within a range of timestamp'), making it easy to understand. However, it doesn't explicitly differentiate from sibling tools like 'get_range_coins_market_chart' or 'get_range_contract_coins_market_chart', which may have overlapping functionality.
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 provides some usage guidance by recommending to 'always use the `jq_filter` parameter to reduce the response size and improve performance' and noting to 'omit if you're sure you don't need the data.' This implies a performance consideration but doesn't specify when to use this tool versus alternatives (e.g., compared to other OHLC or market chart tools in the sibling list) or any prerequisites. The guidance is helpful but incomplete for tool selection.
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?
Annotations provide readOnlyHint=true, indicating a safe read operation. The description adds value by mentioning performance considerations (using jq_filter to reduce response size) and specifying the data scope ('last 24 hours'), which aren't covered by annotations. However, it lacks details on rate limits, authentication needs, or pagination behavior, leaving room for improvement in behavioral context.
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 relatively concise, with two sentences of guidance followed by the purpose statement. However, it includes an extensive output schema (provided as a response schema in the description text), which is verbose and not strictly necessary since there's no output schema field in the tool definition. This reduces efficiency, but the core description sentences are front-loaded and waste-free.
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 complexity (querying multiple data types), annotations cover safety (read-only), and the input schema is fully described. The description adds context on performance optimization and temporal scope. However, without an output schema in the tool definition, the embedded response schema in the description compensates but isn't ideal. Overall, it's mostly complete but could better integrate with structured fields.
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%, so the input schema fully documents the two parameters (show_max and jq_filter). The description emphasizes using jq_filter for performance but doesn't add semantic details beyond what the schema provides (e.g., examples of jq_filter usage are in the schema). With high schema coverage, the baseline score of 3 is appropriate as the description adds minimal parameter semantics.
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's purpose: 'query trending search coins, NFTs and categories on CoinGecko in the last 24 hours.' It specifies the verb ('query'), resource ('trending search coins, NFTs and categories'), and temporal scope ('last 24 hours'). However, it doesn't explicitly differentiate from sibling tools like 'get_search' or 'get_pools_onchain_trending_search,' which prevents a perfect score.
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 provides some usage guidance by recommending to 'always use the `jq_filter` parameter to reduce the response size and improve performance,' with a conditional 'Only omit if you're sure you don't need the data.' This implies a best practice but doesn't specify when to use this tool versus alternatives (e.g., other trending or search tools in the sibling list), nor does it mention 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?
The annotations already declare readOnlyHint=true, so the agent knows this is a safe read operation. The description adds useful behavioral context about performance optimization through jq_filter usage and mentions the response includes exchange data and tickers. However, it doesn't disclose other important traits like rate limits, authentication needs, or pagination behavior. With annotations covering the safety profile, a 3 is appropriate—the description adds some value but not comprehensive behavioral context.
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 appropriately sized with three sentences: performance advice, exception, and core purpose. It's front-loaded with the most actionable information (jq_filter usage). However, the inclusion of the full output schema within the description text adds unnecessary bulk that could be separated, slightly reducing efficiency.
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 complexity (querying exchange data with tickers), the description is reasonably complete. It outlines the tool's purpose and provides performance guidance. The annotations cover read-only safety, and while there's no output schema in the structured data, the description includes a detailed response schema, compensating for that gap. However, it lacks information on error handling or example usage, preventing a perfect score.
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 67%, with two parameters well-documented in the schema (dex_pair_format and jq_filter). The description emphasizes the jq_filter parameter for performance but doesn't add semantic meaning beyond what the schema provides for any parameters. It doesn't explain the 'id' parameter's purpose or format. Given the moderate schema coverage, the description compensates minimally, warranting a 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 tool's purpose: 'query exchange's data (name, year established, country, ...), exchange volume in BTC and top 100 tickers based on exchange's ID'. It specifies the verb ('query'), resource ('exchange's data'), and scope ('based on exchange's ID'), making it easy to understand what the tool does. However, it doesn't explicitly differentiate from sibling tools like 'get_exchanges_tickers' or 'get_list_exchanges', which prevents a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear usage guidance with the strong recommendation to 'always use the `jq_filter` parameter to reduce the response size and improve performance', including an exception case ('Only omit if you're sure you don't need the data'). This gives practical advice for when to use the parameter. However, it doesn't specify when to use this tool versus alternatives among the many sibling tools, which limits the score.
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?
Annotations provide readOnlyHint=true, indicating a safe read operation. The description adds behavioral context by emphasizing performance optimization with jq_filter and describing the response content (ID and name), which is useful beyond annotations. However, it doesn't cover other traits like rate limits, pagination, or error handling, leaving some gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with usage advice and purpose, but includes an output schema section that is redundant since there's no output schema in context signals, adding unnecessary length. The sentences are mostly efficient, but the inclusion of schema details reduces overall conciseness.
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 (2 parameters, no required params, no output schema), the description is mostly complete: it covers purpose, usage guidelines for parameters, and response content. However, it could improve by addressing sibling differentiation or more behavioral details, but it's adequate for this simple query 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%, so the schema fully documents both parameters (status and jq_filter). The description adds value by strongly recommending jq_filter for performance and explaining its purpose, but doesn't provide additional semantic details beyond what's in the schema, such as default behaviors or usage examples for status.
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 states 'query all the exchanges with ID and name', which clearly indicates the verb (query) and resource (exchanges) with specific fields (ID and name). However, it doesn't explicitly differentiate from sibling tools like 'get_exchanges_tickers' or 'get_id_exchanges', which likely serve different purposes, so it misses full sibling distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use the jq_filter parameter ('always use... to reduce response size and improve performance') and when to omit it ('Only omit if you're sure you don't need the data'). However, it doesn't specify when to use this tool versus alternatives like other exchange-related siblings, so it lacks explicit alternative 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?
Annotations provide readOnlyHint=true, indicating a safe read operation. The description adds valuable behavioral context: it warns about large response sizes and recommends using jq_filter for performance, which isn't covered by annotations. It also mentions the tool queries 'latest pools', suggesting recency, though it doesn't detail pagination, rate limits, or authentication needs. The description doesn't contradict annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with a performance tip and purpose statement, but it includes an extensive output schema that duplicates information better placed in a structured output_schema field. The first two sentences are concise and relevant, but the embedded JSON schema adds unnecessary length and reduces overall efficiency.
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 complexity (querying pools across networks) and the absence of an output schema, the description provides a detailed response schema, which compensates for the lack of structured output documentation. However, it doesn't cover all contextual aspects like pagination behavior, rate limits, or error handling, leaving some gaps for a tool that likely returns large datasets.
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%, so the schema fully documents all 4 parameters. The description adds minimal parameter semantics by emphasizing jq_filter for performance, but doesn't explain other parameters like 'include' or 'page' beyond what the schema provides. With high schema coverage, the baseline is 3, and the description doesn't significantly enhance understanding.
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 states 'query all the latest pools across all networks on GeckoTerminal', which clearly specifies the verb (query), resource (latest pools), and scope (all networks). It distinguishes from siblings like 'get_network_networks_onchain_new_pools' by emphasizing 'all networks' rather than a specific network, 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 Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides some usage guidance by recommending 'always use the jq_filter parameter to reduce response size and improve performance', which implies this tool returns large datasets. However, it doesn't specify when to use this tool versus alternatives like 'get_pools_onchain_megafilter' or 'get_search_onchain_pools', nor does it mention prerequisites or exclusions beyond the performance tip.
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?
The annotations provide readOnlyHint=true, indicating a safe read operation. The description adds behavioral context by specifying that it returns the 'latest 200 coins' and includes a response schema, which clarifies the output structure. However, it doesn't disclose other traits like rate limits, authentication needs, or pagination behavior. With annotations covering safety, the description adds moderate value, warranting a score of 3.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with usage advice and purpose, but it includes a verbose response schema that duplicates structured data, reducing efficiency. The first two sentences are valuable, but the schema section could be omitted since there's no output schema field, making it somewhat bloated. It earns a 3 for mixed conciseness.
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 (1 optional parameter) and annotations covering safety, the description is mostly complete. It explains the purpose, usage, and output format via the embedded schema. However, it lacks details on error handling or limitations like the 200-coin limit's implications, slightly reducing completeness. With no output schema, the included response schema helps, but it's not fully integrated.
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 the single parameter 'jq_filter,' detailing its purpose and examples. The description reinforces this by emphasizing its use for performance but doesn't add new semantic details beyond what the schema provides. With high schema coverage, the baseline is 3, as the description doesn't significantly enhance parameter understanding.
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's purpose: 'query the latest 200 coins that recently listed on CoinGecko.' It specifies the verb 'query' and resource 'coins,' and distinguishes itself from siblings by focusing on newly listed coins rather than other coin data like markets, history, or categories. However, it doesn't explicitly differentiate from tools like 'get_search_trending' or 'get_coins_top_gainers_losers' that might also involve recent activity, making it a 4 instead of a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear usage guidance: 'always use the `jq_filter` parameter to reduce the response size and improve performance. Only omit if you're sure you don't need the data.' This gives explicit when-to-use advice for the parameter. However, it lacks guidance on when to use this tool versus sibling alternatives like 'get_coins_markets' or 'get_search_trending' for similar data needs, preventing a score of 5.
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?
Annotations provide readOnlyHint=true, indicating a safe read operation. The description adds valuable behavioral context beyond annotations: it emphasizes performance optimization through jq_filter usage and warns about large response sizes. It also implicitly suggests the tool returns detailed metadata, which aligns with the output schema snippet. No contradiction with annotations exists, and the added context is helpful for agent decision-making.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with performance advice, followed by the core purpose statement. However, it includes an extensive output schema (over 100 lines) that duplicates structured data, which is unnecessary and reduces conciseness. The first two sentences are efficient, but the schema bloat makes the overall description verbose and poorly structured for quick comprehension.
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 tool's complexity (4 parameters, 50% schema coverage, no output schema in structured fields), the description is partially complete. It covers parameter semantics and behavioral traits well, but lacks explicit differentiation from sibling tools and doesn't detail the response format beyond the embedded schema. The output schema snippet helps, but it's not integrated into the description effectively, leaving gaps in contextual understanding.
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 description coverage is 50%, with only 'include' and 'jq_filter' having descriptions. The description compensates by explaining the purpose of 'jq_filter' in detail (reducing response size, improving performance) and providing an example usage. It also mentions that pool metadata is queried 'based on a provided pool contract address on a network,' which clarifies the semantics of 'pool_address' and 'network' parameters. This adds meaningful context beyond the 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?
The description clearly states the tool's purpose: 'query pool metadata (base and quote token details, image, socials, websites, description, contract address, etc.) based on a provided pool contract address on a network.' This is a specific verb ('query') with resource ('pool metadata') and scope ('on a network'). However, it doesn't explicitly differentiate from sibling tools like 'get_tokens_networks_onchain_info' or 'get_pools_networks_onchain_trades', which reduces clarity.
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 provides some usage guidance: it strongly recommends using the 'jq_filter' parameter to reduce response size and improve performance, and advises omitting it only if certain data isn't needed. However, it doesn't specify when to use this tool versus alternatives (e.g., 'get_pools_onchain_megafilter' or 'get_search_onchain_pools'), nor does it mention prerequisites like required parameters. The guidance is implied but not comprehensive.
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?
The annotation 'readOnlyHint: true' already indicates this is a safe read operation. The description adds useful behavioral context: it emphasizes performance optimization with 'jq_filter', mentions the response contains arrays of numbers for market data, and specifies the tool is for historical data within a time range. However, it doesn't disclose other behavioral traits like rate limits, authentication needs, or data freshness that aren't covered by annotations.
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 appropriately sized and front-loaded with critical usage advice about 'jq_filter'. The second sentence clearly states the tool's purpose. However, the inclusion of the full output schema within the description text is redundant and adds unnecessary length, as this information should be in a separate structured field.
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 complexity (8 parameters, historical data query) and the presence of annotations (readOnlyHint) but no output schema, the description is moderately complete. It covers the core purpose and key behavioral advice about response filtering, but doesn't explain the structure of returned arrays (e.g., that each inner array contains [timestamp, value] pairs) or provide guidance on parameter combinations. The embedded output schema partially compensates for the missing structured output schema.
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 75%, so the schema already documents most parameters well. The description adds marginal value by mentioning 'asset platform' (implied by 'id' parameter) and 'particular token contract address' (matching 'contract_address'), but doesn't explain parameter interactions or provide additional semantics beyond what's in the schema. With high schema coverage, the baseline score of 3 is appropriate.
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's purpose: 'get the historical chart data within certain time range in UNIX along with price, market cap and 24hr volume based on asset platform and particular token contract address.' It specifies the verb ('get'), resource ('historical chart data'), and key parameters (time range, asset platform, contract address). However, it doesn't explicitly differentiate from similar siblings like 'get_range_coins_market_chart' or 'get_nfts_market_chart' beyond mentioning 'contract address'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use the 'jq_filter' parameter ('always use... to reduce response size and improve performance') and when to omit it ('Only omit if you're sure you don't need the data'). It also implies usage context by specifying the data types (price, market cap, volume) and that it's for historical chart data. However, it doesn't mention when to choose this tool over alternatives like 'get_range_coins_market_chart' or 'get_simple_price'.
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?
Annotations declare readOnlyHint=true, which the description aligns with by describing a search operation. The description adds valuable behavioral context beyond annotations: performance advice (use jq_filter to reduce response size), a caution (omit only if sure not needed), and details on response structure (coins, categories, markets, etc.). No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with usage advice but includes an extensive embedded JSON output schema that duplicates structured data, reducing conciseness. The first two sentences are efficient, but the schema adds bulk without earning its place in the description text.
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 moderate complexity (search with performance tuning), 100% schema coverage, and readOnlyHint annotation, the description is fairly complete. It explains the search scope, provides behavioral tips, and details response structure via embedded schema. However, no output schema is provided separately, so the embedded one compensates adequately.
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%, so the schema fully documents both parameters ('query' and 'jq_filter'). The description adds minimal param semantics beyond the schema—it emphasizes jq_filter's importance but doesn't explain syntax or format details. Baseline 3 is appropriate as the schema handles most 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?
The description clearly states the tool searches for 'coins, categories and markets listed on CoinGecko' with a specific verb ('search') and resource scope. It distinguishes from some siblings (e.g., 'get_search_onchain_pools', 'get_search_trending') by specifying the search domain, though not all alternatives are explicitly named.
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 provides implied usage guidance by emphasizing the 'jq_filter' parameter for performance and listing searchable entities (coins, categories, markets). However, it lacks explicit when-to-use vs. alternatives (e.g., 'search_docs' or other 'get_search_*' tools) or clear exclusions, leaving some ambiguity.
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?
Annotations provide readOnlyHint=true, indicating this is a safe read operation. The description adds behavioral context by emphasizing performance optimization with jq_filter and noting the tool queries 'all' supported currencies, which clarifies scope. However, it doesn't disclose other traits like rate limits, authentication needs, or response format details. With annotations covering safety, the description adds some value but not rich behavioral context.
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 front-loaded with key guidance in the first two sentences, followed by the purpose statement. However, the inclusion of a JSON schema snippet in the description is redundant since there's no output schema in context signals, and it adds clutter. Overall, it's efficient but could be more streamlined by removing the schema duplication.
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 1 parameter with full schema coverage, readOnlyHint annotation, and no output schema, the description adequately covers the tool's purpose and parameter guidance. However, it lacks details on response format (e.g., what currencies are returned as strings) and doesn't differentiate from sibling tools, leaving gaps in contextual understanding for an agent.
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 1 parameter with 100% description coverage, detailing jq_filter's purpose and examples. The description reinforces this by advising to 'always use' it for performance, adding usage context beyond the schema. However, it doesn't provide additional semantic details like specific filter examples for this tool's response. Baseline 3 is appropriate as the schema does heavy lifting.
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's purpose: 'query all the supported currencies on CoinGecko'. This is a specific verb ('query') and resource ('supported currencies'), though it doesn't explicitly differentiate from sibling tools like 'get_simple_price' or 'get_global' which might also involve currencies. The purpose is clear but lacks sibling differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use the jq_filter parameter ('always use... to reduce response size and improve performance') and when to omit it ('Only omit if you're sure you don't need the data'). However, it doesn't mention when to use this tool versus alternative currency-related tools in the sibling list, such as 'get_simple_price' or 'get_coins_markets'. The guidance is clear for parameter usage but lacks tool-level context.
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?
The annotation readOnlyHint=true already indicates this is a safe read operation. The description adds useful context about what data is returned (metadata and market data from CoinGecko) and the specific lookup method (contract address + platform), which goes beyond the annotation. However, it doesn't disclose behavioral traits like rate limits, authentication needs, or pagination. With annotations covering safety, a 3 is appropriate as the description adds some value but not comprehensive behavioral context.
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, well-structured sentence that efficiently conveys the tool's purpose, scope, and key parameters. It uses bolding for emphasis without being excessive. While it could be slightly more concise by removing 'This endpoint allows you to', the information density is high with zero wasted words.
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 tool's moderate complexity (2 required parameters, no output schema, read-only operation), the description adequately covers the what and how but has gaps. It explains the data returned and lookup method, but doesn't address parameter formats, error conditions, or response structure. With no output schema and 0% schema coverage, the description should do more to compensate, making it minimally viable but incomplete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 0%, meaning neither parameter (id, contract_address) has descriptions in the schema. The description mentions 'asset platform and a particular token contract address', which partially explains the parameters but doesn't specify that 'id' corresponds to the asset platform or provide format examples. It adds some meaning but doesn't fully compensate for the complete lack of schema documentation.
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 explicitly states the verb 'query' and specifies the resources: 'metadata (image, websites, socials, description, contract address, etc.) and market data (price, ATH, exchange tickers, etc.) of a coin'. It clearly distinguishes this tool from siblings by focusing on contract-based coin data retrieval, unlike tools like get_coins_markets (general market data) or get_id_coins (ID-based queries).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for usage: 'based on an asset platform and a particular token contract address'. It implies this tool is for contract-specific queries, but does not explicitly state when NOT to use it or name alternatives like get_id_coins for non-contract-based queries. The context is sufficient but lacks explicit exclusions or named alternatives.
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?
The annotation 'readOnlyHint: true' already indicates this is a safe read operation. The description adds value by emphasizing performance optimization with 'jq_filter' and specifying the data types returned (floor price, market cap, volume in native/USD). However, it doesn't disclose other behavioral traits like rate limits, authentication needs, or pagination behavior, leaving some gaps despite the annotation covering the safety aspect.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is moderately concise but has structural issues. The first two sentences focus on 'jq_filter' usage, which is helpful but front-loads parameter advice over core purpose. The third sentence states the tool's purpose clearly. However, the inclusion of a full output schema in the description text is redundant and verbose, as context signals indicate 'Has output schema: false', but this embedded schema adds unnecessary length without being part of the structured output schema field.
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 complexity (3 parameters, historical data query), the description is fairly complete. It covers the tool's purpose, key parameters, and performance tips, and the embedded output schema provides detailed return value information (though redundantly). With annotations indicating read-only safety and good parameter coverage, the main gap is lack of sibling differentiation, but overall it supports effective agent use.
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 description coverage is 67%, with 'days' and 'jq_filter' well-documented in the schema. The description adds meaningful context: it explains the purpose of 'jq_filter' for performance and references the output schema for field availability. It also clarifies that 'days' specifies 'number of days away from now' for historical data. This compensates well for the partial schema coverage, though it doesn't detail the 'id' parameter beyond what's implied.
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's purpose: 'query historical market data of a NFT collection, including floor price, market cap, and 24hr volume, by number of days away from now.' This specifies the verb ('query'), resource ('historical market data of a NFT collection'), and key data fields. However, it doesn't explicitly differentiate from sibling tools like 'get_range_coins_market_chart' or 'get_markets_nfts', which might offer similar functionality for different asset types.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear usage guidance for the 'jq_filter' parameter ('always use... to reduce response size and improve performance. Only omit if you're sure you don't need the data'), which helps optimize tool invocation. However, it lacks explicit guidance on when to use this tool versus alternatives (e.g., 'get_range_coins_market_chart' for coins vs. NFTs), and doesn't mention prerequisites or exclusions beyond the parameter advice.
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?
Annotations provide readOnlyHint=true, indicating a safe read operation. The description adds valuable behavioral context beyond annotations: it emphasizes performance optimization with 'jq_filter', warns about response size, and specifies the tool returns historical data (not real-time). It doesn't cover rate limits, authentication needs, or pagination, but given annotations cover safety, this adds meaningful context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with performance advice, followed by the core purpose. However, it includes an embedded JSON output schema that duplicates information better placed in structured fields, adding bulk without earning its place in the description text. The first two sentences are efficient, but the schema inclusion reduces overall conciseness.
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 has annotations (readOnlyHint), moderate parameter complexity (4 params, 2 required), and no output schema, the description provides sufficient context: it clarifies the tool's purpose, offers usage tips, and references the response structure. It could improve by explaining the 'days' enum options or differentiating from siblings, but it covers key aspects for a read-only historical data tool.
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 description coverage is 50%, with only 'days' and 'jq_filter' having descriptions. The description compensates by explaining the purpose of 'jq_filter' in reducing response size and improving performance, and it references the output schema for available fields. It doesn't detail 'network' or 'token_address' parameters, but the tool's purpose implies their roles, and the schema covers required fields adequately.
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 states 'get the historical token holders chart based on the provided token contract address on a network', which clearly specifies the verb ('get'), resource ('historical token holders chart'), and key inputs (token address, network). It distinguishes from most siblings by focusing on holders data rather than prices, pools, or other metrics, though it doesn't explicitly differentiate from similar tools like 'get_tokens_networks_onchain_top_holders'.
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 includes a performance tip about using 'jq_filter' to reduce response size, which provides some usage guidance. However, it doesn't specify when to use this tool versus alternatives (e.g., 'get_tokens_networks_onchain_top_holders' for current top holders vs. historical chart), nor does it mention prerequisites or exclusions. The guidance is implied rather than explicit.
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?
The annotation readOnlyHint=true already indicates this is a safe read operation. The description adds useful context about what data categories are returned (metadata and market data with specific examples), but doesn't disclose behavioral traits like rate limits, authentication requirements, response format, or pagination. With annotations covering the safety profile, this earns a baseline 3 for adding some value without contradictions.
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, well-structured sentence that efficiently conveys the tool's purpose with zero wasted words. It's front-loaded with the core functionality and uses bold formatting for key concepts, making it easy to parse while remaining comprehensive.
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 read-only tool with good annotations and high schema coverage, the description provides adequate context about what data is returned. However, without an output schema, it could benefit from more detail about response structure or data formats. The description covers the essential 'what' but leaves some gaps in 'how' the data is organized in response.
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 high at 89%, so the schema already documents most parameters well. The description doesn't add specific parameter semantics beyond implying the 'id' parameter is for coin identification. It mentions data categories like 'market data' which loosely maps to the market_data parameter, but doesn't explain parameter interactions or defaults beyond what the schema 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 clearly states the specific verb 'query' and resource 'metadata and market data of a coin from the CoinGecko coin page', with explicit examples of what metadata (image, websites, socials, description, contract address) and market data (price, ATH, exchange tickers) are included. It distinguishes from siblings by specifying it's based on 'coin ID' rather than contract addresses, markets, or other parameters used by other 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?
The description implies usage context by stating it queries 'based on a particular coin ID', suggesting this is for looking up specific coins rather than lists or markets. However, it doesn't explicitly state when to use this versus alternatives like get_coins_markets (for multiple coins) or get_coins_contract (for contract-based lookup), nor does it mention prerequisites like needing a valid coin ID.
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?
Annotations provide readOnlyHint=true, but the description adds valuable behavioral context: it emphasizes performance optimization through jq_filter usage, mentions that the endpoint queries 'all' supported categories (implying potentially large datasets), and includes a detailed response schema showing the structure of returned data. This goes beyond what annotations provide by explaining practical considerations for efficient usage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized but not optimally structured. The performance guidance about jq_filter comes first (good front-loading), but the purpose statement is buried after it. The inclusion of the full response schema within the description text adds significant length that might be better handled through a separate output schema field. Every sentence earns its place, but the organization could be improved.
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 purpose (querying categories), 3 parameters with full schema coverage, read-only annotation, and no output schema, the description provides good context. It explains the tool's purpose, gives practical usage guidance for performance, and includes the response structure. The main gap is lack of comparison with sibling category tools, but otherwise it's reasonably complete for this type of query 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%, so all parameters are well-documented in the schema itself. The description adds specific guidance about jq_filter ('always use... to reduce response size') and references the output schema for available fields, but doesn't provide additional semantic meaning beyond what's already in the parameter descriptions. This meets the baseline 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?
The description states 'query all the supported categories on GeckoTerminal' which clearly indicates the verb (query) and resource (categories). It distinguishes from many sibling tools that focus on tokens, pools, or exchanges rather than categories. However, it doesn't specifically differentiate from 'get_list_coins_categories' or 'get_pools_onchain_categories' which also handle categories.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance about when to use the jq_filter parameter ('always use... to reduce response size and improve performance') and when to omit it ('Only omit if you're sure you don't need the data'). This gives clear context for parameter usage. However, it doesn't specify when to use this tool versus alternative category-related tools like 'get_list_coins_categories' or 'get_pools_onchain_categories'.
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 adds valuable behavioral context beyond the annotations. While annotations provide 'readOnlyHint: true', the description explains performance considerations (using 'jq_filter' to reduce response size) and hints at potential large data volumes. It doesn't contradict annotations and offers practical insights that help an agent use the tool effectively, though it could mention pagination or rate limits for a higher score.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with practical advice on 'jq_filter', which is useful, but it includes an embedded JSON output schema that duplicates structured data, reducing conciseness. The first two sentences are efficient, but the schema inclusion adds unnecessary length without adding value beyond what could be in an output schema field, making it somewhat bloated.
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 complexity (6 parameters, 83% schema coverage, no output schema), the description is reasonably complete. It covers purpose, usage tips, and includes an output schema in the description to compensate for the lack of a structured output schema. However, it could be more thorough by explaining error cases or linking to sibling tools, but it's adequate for the context.
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 schema description coverage at 83%, the input schema already documents most parameters well. The description doesn't add significant semantic details about parameters beyond what's in the schema, such as explaining 'entity_id' further or providing examples for 'coin_ids'. It mentions 'jq_filter' in usage guidelines but doesn't elaborate on its semantics beyond the schema's description, so it meets the baseline for high 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's purpose: 'query public companies & governments' cryptocurrency transaction history by Entity ID'. It specifies the verb ('query'), resource ('transaction history'), and scope ('public companies & governments'), which is specific and actionable. However, it doesn't explicitly differentiate from sibling tools like 'get_holding_chart_public_treasury', which might provide related but different data, keeping it from a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear usage guidance by emphasizing the importance of using the 'jq_filter' parameter to reduce response size and improve performance, with a note to omit only if unnecessary. This gives practical advice on when to use this parameter. However, it lacks explicit guidance on when to use this tool versus alternatives (e.g., sibling tools like 'get_holding_chart_public_treasury'), which prevents a score of 5.
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?
Annotations provide readOnlyHint=true, indicating a safe read operation. The description adds behavioral context by emphasizing performance optimization through jq_filter usage and warning about response size, which is valuable. However, it doesn't disclose other traits like rate limits, authentication needs, or error handling, leaving some gaps in behavioral understanding.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with key usage advice, but it includes an extensive output schema that duplicates structured data, making it verbose. The first two sentences are efficient, but the schema section adds unnecessary bulk, reducing overall conciseness. It could be more streamlined by omitting the schema or summarizing it briefly.
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 (1 parameter, no required parameters) and annotations covering read-only safety, the description is mostly complete. It explains the purpose, usage guidelines, and includes an output schema (though not needed per rules). However, it lacks details on error cases or integration context, leaving minor gaps for a fully informed agent.
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 description coverage is 100%, so the schema fully documents the jq_filter parameter. The description adds semantic value by explaining why to use jq_filter ('to reduce the response size and improve performance') and when to omit it, providing practical guidance beyond the schema's technical details. With only one parameter, this is sufficient for a high score.
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's purpose: 'query cryptocurrency global data including active cryptocurrencies, markets, total crypto market cap and etc.' It specifies the verb 'query' and resource 'cryptocurrency global data' with examples. However, it doesn't explicitly differentiate from sibling tools like get_simple_price or get_coins_markets, which also provide cryptocurrency data but with different scopes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage guidance: 'always use the `jq_filter` parameter to reduce the response size and improve performance. Only omit if you're sure you don't need the data.' This tells the agent when to use the parameter and when it might be omitted, offering clear operational advice beyond basic functionality.
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?
Annotations provide readOnlyHint=true, but the description adds valuable behavioral context: it discloses the 300-trade limit, 24-hour time window, and cross-pool scope. It also includes performance guidance about using jq_filter to reduce response size. While it doesn't mention rate limits or authentication needs, it goes beyond annotations by specifying operational constraints and optimization advice.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with important usage advice and purpose, but includes an extensive output schema that duplicates information better placed in structured fields. The first two sentences are valuable, but the schema listing adds bulk without earning its place in the description text, reducing overall efficiency.
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 complexity (trade querying with multiple filters) and the presence of annotations (readOnlyHint) but no output schema, the description does well: it explains the query scope, provides performance advice, and includes the response structure. However, it could better address parameter interactions or error cases. The output schema in the description partially compensates for the lack of structured output schema.
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 50% (2 of 4 parameters have descriptions). The description doesn't explicitly explain any parameters beyond what's in the schema. However, it implies the purpose of network and token_address through the query context. With moderate schema coverage, the description doesn't compensate significantly but doesn't contradict the schema either, warranting the baseline score.
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's purpose: 'query the last 300 trades in the past 24 hours, across all pools, based on the provided token contract address on a network.' This specifies the verb ('query'), resource ('trades'), scope ('last 300 trades in the past 24 hours, across all pools'), and distinguishes it from siblings like get_pools_networks_onchain_trades (which focuses on pools) or get_tokens_networks_onchain_info (which provides general token info).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use the tool: for querying recent trades for a specific token on a network. It distinguishes from siblings by specifying the trade-focused nature, though it doesn't explicitly name alternatives or state when not to use it. The jq_filter advice adds practical usage context, but lacks explicit exclusions or comparisons to other trade-related tools.
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?
Annotations provide readOnlyHint=true, indicating this is a safe read operation. The description adds value by emphasizing performance optimization with jq_filter and listing the types of metadata returned (name, symbol, etc.), which goes beyond the annotation. However, it doesn't mention rate limits, authentication needs, or error conditions.
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 front-loaded with key usage advice and purpose, followed by a detailed response schema. The first two sentences are highly relevant, but the embedded JSON schema makes it lengthy. However, the schema is necessary given no output schema field, so the structure is appropriate.
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 3 parameters, low schema coverage, no output schema, and annotations only covering read-only status, the description does well by including a full response schema and usage tips. It explains what data is returned and how to filter it, making it fairly complete for a query tool, though it could add more on network/address formats.
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 description coverage is low at 33%, with only jq_filter having a description. The description compensates by explaining jq_filter's purpose ('reduce response size and improve performance') and listing the metadata fields available, which helps understand what 'address' and 'network' parameters are used for. It doesn't specify format for address or network, but adds meaningful context.
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 explicitly states the tool's purpose: 'query token metadata (name, symbol, CoinGecko ID, image, socials, websites, description, etc.) based on a provided token contract address on a network.' This is a specific verb ('query') with clear resources ('token metadata') and distinguishes it from siblings like price or pool tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear usage guidance: 'always use the `jq_filter` parameter to reduce the response size and improve performance. Only omit if you're sure you don't need the data.' This gives practical advice on parameter usage but doesn't explicitly state when to use this tool versus alternatives like other token info tools in the sibling list.
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:

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

Score Badge

Copy to your README.md:

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

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/IAcomunIA/MCP_firts'

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