DeFi Trading Agent MCP Server

by edkdev

Overview Schema Related Servers Score Discussions

JavaScript

Local

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, but there is some overlap in data retrieval tools like get_token_data and get_token_info, which could cause confusion about which to use for token details. The gasless swap tools (get_gasless_price, get_gasless_quote, submit_gasless_swap) are clearly scoped, but multiple 'get' tools for pools and tokens might require careful selection.
Naming Consistency5/5
All tools follow a consistent snake_case naming pattern with clear verb_noun structures, such as 'get_token_price', 'execute_swap', and 'search_pools'. This predictability makes it easy for an agent to understand and navigate the toolset without confusion from mixed conventions.
Tool Count3/5
With 32 tools, the count is borderline high for a DeFi trading server, potentially overwhelming for agents. While the domain is broad, covering swaps, portfolio management, and data retrieval, some tools might be redundant or could be consolidated, such as multiple pool and token data fetchers.
Completeness5/5
The toolset provides comprehensive coverage for DeFi trading, including swap execution (with gasless options), portfolio tracking, token and pool data retrieval, and network/DEX information. There are no obvious gaps; it supports full workflows from price checking to transaction submission and status monitoring.
Average 3.1/5 across 32 of 32 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- 3 of 5 community issues answered or closed in the last 6 months
- 8 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is failing
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

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

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

How is the quality score calculated?

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

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

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

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

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but only states it retrieves status without disclosing behavioral traits. It doesn't mention whether this is a read-only operation, what the status response includes, potential errors, rate limits, or authentication requirements for a gasless swap system.
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, focused sentence with zero wasted words. It's front-loaded with the core purpose and efficiently communicates the essential function without unnecessary elaboration.
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 status-checking tool with no annotations and no output schema, the description is insufficient. It doesn't explain what status information is returned, possible status values, or how to interpret results. Given the complexity of gasless swaps and lack of structured output documentation, more context is needed.
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%, providing clear parameter documentation. The description adds no additional parameter semantics beyond what's in the schema, but since the schema fully describes both required parameters, this meets the baseline expectation 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 action ('Get the status') and resource ('submitted gasless swap'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'submit_gasless_swap' beyond the obvious status vs. submission distinction, missing opportunities to clarify scope boundaries.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided about when to use this tool versus alternatives. While the name implies it's for checking status after submission, there's no explicit mention of prerequisites (e.g., must have a tradeHash from 'submit_gasless_swap') or when other tools might be more appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It states the tool retrieves a list but lacks details on behavioral traits such as rate limits, authentication needs, pagination, error handling, or what 'liquidity sources' entails (e.g., types, formats, or freshness). This is a significant gap for a tool with no annotation coverage, making it inadequate for informed agent use.
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 core purpose without unnecessary words. It directly states what the tool does and its scope, with zero waste or redundancy, making it highly concise and well-structured 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?
Given no annotations, no output schema, and a simple input schema, the description is incomplete. It lacks crucial context like what the output includes (e.g., list format, data fields), behavioral constraints, or how it fits among siblings. For a tool in a complex DeFi context with many related tools, this minimal description fails to provide sufficient guidance 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 100%, with the single parameter 'chainId' documented as 'Blockchain ID to get sources for'. The description adds no additional meaning beyond this, such as valid chain IDs or examples. Since the schema fully covers the parameter, the baseline score of 3 is appropriate, as the description doesn't compensate but also doesn't need to given high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get list') and resource ('liquidity sources'), specifying the scope ('available on a specific chain'). It distinguishes from siblings like get_supported_chains or get_gasless_chains by focusing on liquidity sources rather than chain metadata or gasless features. However, it doesn't explicitly differentiate from tools like get_multiple_pools_data or get_top_pools_by_dex, which might overlap in purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides minimal guidance, only indicating to use it for getting liquidity sources on a specific chain. It offers no explicit when-to-use vs. alternatives, prerequisites, or exclusions. For example, it doesn't clarify when to prefer this over get_supported_dexes or get_top_pools_by_token, leaving usage context implied rather than stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but offers minimal behavioral insight. It states it 'gets data' but doesn't disclose if this is a read-only operation, potential rate limits, authentication needs, error conditions, or what the output format looks like (e.g., JSON structure). For a tool with 4 parameters and no output schema, this is inadequate.
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 directly states the tool's function without redundancy. It's front-loaded with the core purpose and wastes no words, making it easy for an agent to parse quickly.
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 4 parameters, no annotations, and no output schema, the description is incomplete. It doesn't explain what 'data' encompasses beyond parameter hints, behavioral traits like safety or performance, or how results are structured. For a data-fetching tool in a complex domain (DeFi pools), this leaves significant gaps 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?
Schema description coverage is 100%, so the schema fully documents all parameters (network, addresses, include, include_volume_breakdown). The description adds no additional meaning beyond implying addresses are for pools, which is already clear from the schema. Baseline 3 is appropriate as 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 action ('Get data') and target resource ('multiple pools by their contract addresses'), making the purpose unambiguous. It distinguishes from siblings like get_token_data (tokens vs pools) and get_pool_ohlcv (specific data types vs general pool data). However, it doesn't specify what 'data' includes beyond what parameters imply, preventing 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 Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives is provided. While the description implies it's for fetching pool data by addresses, it doesn't contrast with siblings like get_top_pools_by_token (which might not require addresses) or search_pools (which might use filters). The agent must infer usage from the name and parameters alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It states what the tool does but reveals nothing about behavioral traits: no information about rate limits, authentication requirements, error conditions, response format, or whether this is a read-only operation. 'Get' implies read-only, but this isn't explicitly confirmed.
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 states the core functionality without unnecessary words. It's appropriately sized for a straightforward data retrieval tool and front-loads the essential information.
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 3 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain what 'data' means in this context (prices, metadata, balances?), doesn't mention any constraints or limitations, and provides no context about the data source or freshness. The agent would need to guess about the tool's behavior and output.
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 documents all three parameters thoroughly. The description adds no additional parameter semantics beyond what's in the schema - it doesn't explain what 'data' includes, what format addresses should use beyond 'comma-separated', or clarify the relationship between parameters.
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 action ('Get data') and resource ('multiple tokens by their contract addresses'), making the purpose understandable. It distinguishes from sibling 'get_token_data' by specifying multiple tokens, but doesn't fully differentiate from other data retrieval tools like 'get_token_info' or 'get_token_price'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided about when to use this tool versus alternatives. With siblings like 'get_token_data', 'get_token_info', 'get_token_price', and 'get_portfolio_tokens', the description offers no context about which tool to choose for different token data needs.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'latest new pools' and 'across all networks', hinting at recency and scope, but fails to detail critical aspects like rate limits, authentication needs, data freshness, pagination behavior beyond the schema, or what 'new' means (e.g., time window). This leaves significant gaps for a tool that likely involves network calls.
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 core purpose without unnecessary words. Every part ('Get latest new pools across all networks') contributes directly to understanding the tool's function, making it highly concise and well-structured.
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 complexity of fetching data across networks with parameters, no annotations, and no output schema, the description is insufficient. It lacks details on behavior (e.g., how 'latest' is defined, error handling), output format, or integration with sibling tools, leaving the agent under-informed for effective 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 100%, so the schema fully documents both parameters ('include' and 'page'). The description adds no additional parameter semantics beyond implying a focus on 'latest new pools', which doesn't clarify parameter usage. This meets the baseline for high schema coverage, but doesn't 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 clearly states the action ('Get') and resource ('latest new pools across all networks'), making the purpose immediately understandable. It doesn't explicitly differentiate from sibling tools like 'get_trending_pools' or 'search_pools', which prevents a perfect score, but the scope ('latest new pools across all networks') provides reasonable distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like 'get_trending_pools', 'search_pools', or 'get_multiple_pools_data'. The description implies it's for retrieving newly created pools, but it doesn't specify use cases, prerequisites, or exclusions, leaving the agent to infer context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states what data is retrieved but omits critical details: whether this is a read-only operation, rate limits, authentication requirements, error handling, or the format/structure of returned OHLCV data. For a tool with 9 parameters and no output schema, this is a significant gap.
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 directly states the tool's purpose without redundancy. It's appropriately sized and front-loaded with the core functionality.
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 (9 parameters, financial data retrieval), lack of annotations, and absence of an output schema, the description is insufficient. It doesn't address behavioral aspects, return format, error conditions, or usage context, leaving significant gaps for an AI agent to understand how to properly invoke and interpret results.
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 documented in the schema. The description adds no additional parameter semantics beyond implying OHLCV data retrieval. It doesn't explain relationships between parameters (e.g., how 'timeframe' interacts with 'aggregate') or provide usage examples.
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 verb ('Get') and resource ('OHLCV data for a pool'), making the purpose unambiguous. It doesn't explicitly distinguish from siblings like 'get_pool_trades' or 'get_multiple_pools_data', but the specific focus on OHLCV data provides implicit differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like 'get_pool_trades' (for trade data) or 'get_multiple_pools_data' (for batch queries). The description lacks context about prerequisites, typical use cases, or performance considerations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions 'recent trades' but doesn't specify time ranges, pagination, rate limits, authentication needs, or what 'recent' means. For a read operation with no structured safety hints, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero waste—it directly states the tool's function without fluff. It's appropriately sized for a straightforward data retrieval tool.
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 no annotations and no output schema, the description is incomplete. It doesn't explain return values (e.g., trade format, timestamps), behavioral constraints, or error handling. For a tool with three parameters and complex sibling context, this lacks necessary context for reliable 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 100%, so the schema already documents all three parameters thoroughly. The description adds no additional meaning beyond implying 'pool' relates to 'poolAddress', which the schema covers. Baseline 3 is appropriate as 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 verb ('Get') and resource ('recent trades for a specific pool'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'get_pool_ohlcv' or 'get_multiple_pools_data' that might also retrieve pool-related data, preventing 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 Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. With siblings like 'get_pool_ohlcv' (likely for OHLCV data) and 'get_multiple_pools_data' (for broader pool metrics), the description lacks any context for selection, leaving the agent to infer based on names alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool retrieves data ('Get'), implying a read-only operation, but doesn't specify aspects like rate limits, authentication needs, pagination, or what 'recently updated' entails (e.g., last hour, day). This is a significant gap for a tool with potential behavioral nuances.
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 directly states the tool's purpose without unnecessary words. It's front-loaded with the core action and resource, making it easy to parse quickly. Every word earns its place.
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 complexity of retrieving 'recently updated tokens' (which implies temporal and possibly other filters), no annotations, and no output schema, the description is incomplete. It lacks details on what information is returned, how 'recently updated' is defined, and behavioral traits like pagination or rate limits, leaving gaps for effective tool 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?
The schema description coverage is 100%, so the schema already documents both parameters (include and network) with descriptions and an enum. The description adds no additional parameter semantics beyond what's in the schema, such as clarifying the meaning of 'recently updated' in relation to the network filter. Baseline 3 is appropriate when the schema handles parameter 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 verb 'Get' and the resource 'recently updated tokens with their information', making the purpose understandable. However, it doesn't distinguish this tool from similar sibling tools like get_token_data, get_token_info, or get_multiple_tokens_data, which all retrieve token information but with different scopes or filters.
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 what 'recently updated' means (e.g., time frame), how it differs from other token retrieval tools in the sibling list, or any prerequisites for usage. This leaves the agent without context for tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions 'Get list' but doesn't disclose behavioral traits like whether this is a read-only operation, if it requires authentication, rate limits, pagination details beyond the schema, or error handling. The description is minimal and doesn't add context beyond the basic action.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero waste. It's front-loaded with the core action and resource, making it easy to parse quickly. Every word earns its place without redundancy.
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 no annotations, no output schema, and a simple input schema, the description is incomplete. It doesn't explain what 'supported DEXes' entails, the return format (e.g., list of names, IDs, metadata), or how pagination works in practice. For a tool with 2 parameters and potential complexity in DEX data, more context is needed.
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 documents both parameters ('network' and 'page') with descriptions. The description adds no additional meaning beyond implying the 'network' parameter is used to filter DEXes, which is already clear from the schema. Baseline 3 is appropriate 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 verb ('Get') and resource ('list of supported DEXes on a specific network'), making the purpose immediately understandable. It distinguishes from siblings by focusing on DEX support rather than tokens, pools, swaps, or other operations. However, it doesn't specify what 'supported' means (e.g., integrated, available for swaps) or the format of the returned list.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. While siblings include network-related tools like 'get_supported_chains' and 'get_gasless_chains', the description doesn't clarify if this is for checking DEX availability before swaps or for general reference. It also lacks prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'indicative price' which implies a read-only, non-destructive operation, but doesn't clarify if this is a simulation, requires authentication, has rate limits, or what the output format might be. For a tool with 5 parameters and no output schema, this leaves significant gaps in understanding how the tool behaves.
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 directly states the tool's purpose without any wasted words. It's appropriately sized for a straightforward tool and front-loaded with the key action, making it easy to parse quickly.
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 complexity (5 parameters, financial/blockchain context), lack of annotations, and absence of an output schema, the description is incomplete. It doesn't address what the tool returns, error conditions, or behavioral constraints. For a price calculation tool in a DeFi context where precision and reliability matter, this leaves too much unspecified for confident 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 100%, so the input schema already documents all parameters thoroughly. The description adds no additional meaning about parameters beyond what's in the schema (e.g., it doesn't explain relationships between buyToken/sellToken or format of sellAmount). With high schema coverage, the baseline score of 3 is appropriate as the description doesn't compensate but also doesn't detract.
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 action ('Get indicative price') and resource ('for a token swap using Aggregator Protocol'), which is specific and actionable. However, it doesn't explicitly differentiate from sibling tools like 'get_swap_quote' or 'get_gasless_price', which appear to serve similar price/quote functions, leaving some ambiguity about when to choose this tool over those alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. With siblings like 'get_swap_quote' and 'get_gasless_price' that likely serve related purposes, there's no indication of context, prerequisites, or exclusions to help an agent select appropriately. Usage is implied only by the tool name and description, not explicitly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'executable quote with transaction data,' which implies this is a read-only operation that prepares data for a swap, but it doesn't disclose critical behaviors like whether this requires authentication, rate limits, network dependencies, or what the output format looks like (e.g., JSON structure). This leaves significant gaps for a tool that likely interacts with blockchain networks.
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 core purpose ('Get executable quote with transaction data for a token swap'). There is zero waste or redundancy, making it highly concise and well-structured 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?
Given the complexity of a token swap tool with 6 parameters, no annotations, and no output schema, the description is incomplete. It doesn't address behavioral aspects like authentication needs, error handling, or output format, which are crucial for an AI agent to use this tool effectively in a blockchain context. The schema covers parameters well, but overall context 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?
The schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds no additional meaning beyond what's in the schema (e.g., it doesn't explain relationships between parameters like how 'sellAmount' interacts with 'sellToken'). Baseline 3 is appropriate as the schema does the heavy lifting, but the description doesn't compensate with extra 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 with a specific verb ('Get') and resource ('executable quote with transaction data for a token swap'). It distinguishes itself from siblings like 'get_swap_price' by emphasizing the executable nature of the quote, though it doesn't explicitly contrast with all similar tools like 'get_gasless_quote'.
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 when to choose this over 'get_swap_price' (which might provide price estimates without transaction data) or 'get_gasless_quote' (which might be for gasless swaps), nor does it specify prerequisites or exclusions for usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure but offers minimal information. It doesn't describe response format, error conditions, rate limits, authentication needs, or whether this is a read-only operation. While 'Get' implies reading, explicit confirmation of safety or side effects would be valuable given the lack of annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that front-loads the core purpose without unnecessary words. It avoids redundancy with the tool name and schema, making it easy to parse quickly. Every word earns its place in conveying the essential function.
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 3 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain what 'token data' returns, how results are structured, or any behavioral nuances. Given the complexity of blockchain data retrieval and the lack of structured context, more detail is needed to guide effective 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 100%, so the schema already documents all three parameters thoroughly. The description adds no additional parameter semantics beyond what's in the schema, such as explaining the relationship between 'network' and 'address' or clarifying the 'include' option's impact. Baseline 3 is appropriate 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 action ('Get') and target resource ('specific token data by contract address'), making the purpose immediately understandable. It distinguishes from siblings like 'get_token_info' or 'get_token_price' by focusing on contract-address-based data retrieval. However, it doesn't specify what 'token data' includes beyond what the schema suggests.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like 'get_token_info', 'get_token_price', or 'get_multiple_tokens_data'. The description doesn't mention prerequisites, constraints, or typical use cases, leaving the agent to infer usage from the tool name and parameters alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden for behavioral disclosure. While it mentions the API source (CoinGecko), it doesn't describe rate limits, authentication requirements, error conditions, response format, or whether this is a read-only operation. For a tool with 7 parameters and no annotations, this is a significant gap 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.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero wasted words. It's appropriately sized for a straightforward data retrieval tool and front-loads the core purpose immediately. Every word earns its place by specifying what, how, and the data source.
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 (7 parameters, no output schema, no annotations), the description is insufficient. It doesn't explain what the tool returns, how results are formatted, error handling, rate limits, or when to use this versus other price-related tools. For a tool interacting with an external API and having multiple configuration options, more contextual information is needed.
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 documented in the schema itself. The description adds no additional parameter information beyond what's already in the schema descriptions. The baseline score of 3 reflects that the schema does the heavy lifting for parameter documentation, though the description doesn't enhance understanding of parameter relationships or usage patterns.
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 action ('Get token prices') and the resource ('by contract addresses'), with the specific data source ('using CoinGecko API') mentioned. It distinguishes this from siblings like 'get_token_data' or 'get_token_info' by focusing specifically on price retrieval rather than broader token information. However, it doesn't explicitly differentiate from 'get_swap_price' which might also retrieve 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. With many sibling tools like 'get_token_data', 'get_token_info', 'get_swap_price', and 'get_gasless_price', there's no indication of when this specific CoinGecko-based price tool is preferred. No context about prerequisites, limitations, or appropriate use cases is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It mentions 'top pools' but doesn't clarify what 'top' means (e.g., by volume, transactions, liquidity), though the schema hints at sorting options. It lacks critical behavioral details like pagination behavior, rate limits, authentication needs, or what the output format looks like.
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 gets straight to the point with zero wasted words. It's appropriately sized for a straightforward data retrieval tool and is perfectly front-loaded.
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 5 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain what constitutes 'top' pools, how results are returned, pagination details, or error conditions. The agent would lack critical context to use this tool effectively despite the good schema coverage.
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 5 parameters. The description adds no additional parameter semantics beyond what's in the schema (e.g., it doesn't explain what 'top' means in relation to the 'sort' parameter or provide examples of DEX IDs). Baseline 3 is appropriate 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 action ('Get top pools') and the target resource ('on a specific DEX'), making the purpose immediately understandable. It distinguishes from siblings like 'get_top_pools_by_token' by specifying the DEX focus, though it doesn't explicitly contrast with other pool-related tools like 'get_trending_pools' or 'search_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 siblings like 'get_top_pools_by_token', 'get_trending_pools', and 'search_pools', there's no indication of which tool is appropriate for different scenarios (e.g., DEX-specific ranking vs. token-specific pools vs. general search).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It states what the tool does but reveals nothing about pagination behavior (implied by 'page' parameter but not explained), rate limits, authentication requirements, error conditions, or what 'top' means quantitatively. The description doesn't explain what constitutes 'top' pools or how many are returned.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that states the core functionality without unnecessary words. It's appropriately sized for a tool with good schema documentation and gets straight to the point. Every word earns its place in conveying the essential purpose.
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 5 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain what 'top' means, how results are ranked, what data is returned, or any behavioral aspects. While the schema covers parameter definitions well, the description fails to provide the contextual understanding needed for effective tool selection and 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 100%, so the schema already documents all 5 parameters thoroughly. The description adds no additional parameter semantics beyond what's in the schema - it mentions 'contract address' which maps to tokenAddress parameter but provides no extra context. Baseline 3 is appropriate when 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 verb 'Get' and resource 'top pools for a specific token', making the purpose immediately understandable. It specifies 'by contract address' which distinguishes it from other pool-related tools like get_top_pools_by_dex or get_trending_pools. However, it doesn't explicitly differentiate from get_multiple_pools_data or search_pools which might 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 multiple pool-related sibling tools (get_top_pools_by_dex, get_trending_pools, search_pools, get_multiple_pools_data), there's no indication of when this specific token-focused pool retrieval is preferred over other pool discovery methods. 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.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. While 'Get' implies a read operation, it doesn't specify whether this is a real-time query, cached data, rate-limited, or what the response format looks like. For a tool with no annotation coverage, this leaves critical behavioral traits undocumented.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero waste. It's appropriately sized and front-loaded, directly stating the tool's purpose without unnecessary elaboration.
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 (fetching trending data across networks with parameters), no annotations, and no output schema, the description is incomplete. It lacks behavioral context, usage differentiation from siblings, and details on return values, making it inadequate for informed 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 100%, so the schema already documents all three parameters thoroughly. The description adds no additional parameter semantics beyond what's in the schema. Baseline 3 is appropriate when the schema does the heavy lifting, though no extra value is added.
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 verb 'Get' and resource 'trending pools across all networks on GeckoTerminal', providing a specific purpose. However, it doesn't explicitly distinguish from its sibling 'get_trending_pools_by_network', which appears to be a more specific version, leaving some ambiguity about when to use one versus the other.
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 a sibling tool 'get_trending_pools_by_network' that likely serves a similar purpose but with network filtering, the lack of differentiation is a significant gap. No context, 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.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure but adds minimal information. It doesn't describe what 'trending' means algorithmically, whether this is a read-only operation (implied by 'Get' but not explicit), what the return format looks like, pagination behavior beyond the 'page' parameter, rate limits, or authentication requirements. For a tool with 4 parameters and no output schema, this leaves significant behavioral gaps.
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 states the core purpose without unnecessary words. It's appropriately sized for a straightforward data retrieval tool and front-loads the essential information. Every word earns its place in this minimal description.
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 moderate complexity (4 parameters, no annotations, no output schema), the description is insufficiently complete. It doesn't explain what constitutes 'trending' pools, what data is returned, how results are ordered, or provide any context about the data source or limitations. With no output schema and behavioral gaps, the agent lacks critical information to understand what this tool actually provides.
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 documented in the schema itself. The description adds no additional parameter information beyond what's already in the schema descriptions (network ID format, include attributes, pagination, duration options). This meets the baseline expectation when schema coverage is complete, but doesn't provide extra context like examples of network IDs beyond what's in the schema or clarification on 'include' parameter usage.
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 action ('Get') and resource ('trending pools on a specific network'), making the purpose immediately understandable. It distinguishes from some siblings like 'get_trending_pools' (which lacks network specificity) and 'get_top_pools_by_dex/token' (which use different ranking criteria). However, it doesn't explicitly contrast with all similar tools like 'get_new_pools' or 'search_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. It doesn't mention what 'trending' means compared to 'top' pools, when to prefer this over 'get_new_pools' or 'search_pools', or any prerequisites for using it. The agent must infer usage context solely from the tool name and parameter schema.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the search functionality without mentioning whether this is a read-only operation, if it requires authentication, rate limits, pagination behavior (implied by the 'page' parameter but not explained), error conditions, or what the output format looks like. For a search tool with zero annotation coverage, this is insufficient.
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 directly states the tool's purpose without unnecessary words. It's appropriately sized for a search tool and front-loaded with the core functionality.
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 complexity (search operation with 4 parameters), no annotations, and no output schema, the description is incomplete. It doesn't explain what the tool returns (pool data structure), how results are ordered, pagination details, or error handling. For a tool that likely returns structured data, this leaves significant gaps for the 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 100%, so the schema already fully documents all four parameters. The description mentions the 'query' parameter's semantics (search by pool address, token address, or token symbol), which adds some context beyond the schema's generic description. However, it doesn't provide additional details about parameter interactions, examples, or constraints beyond what's 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: 'Search for pools by query (pool address, token address, or token symbol)'. It specifies the verb ('search'), resource ('pools'), and search criteria. However, it doesn't explicitly differentiate from sibling tools like 'get_top_pools_by_dex' or 'get_trending_pools', which also retrieve pool information but with different selection criteria.
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 sibling tools like 'get_multiple_pools_data' or 'get_top_pools_by_dex', nor does it specify use cases, prerequisites, or exclusions. The agent must infer usage from the name and description alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the use of 'ethers.js' but doesn't describe error handling, input validation, or output format. For a conversion tool with no annotation coverage, this leaves significant gaps in understanding how it behaves in practice.
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 directly states the tool's function. It's front-loaded with the core purpose and uses no unnecessary words, making it easy to parse and understand quickly.
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 low complexity (2 parameters, no output schema, no annotations), the description is minimally adequate. It covers the basic purpose but lacks details on behavioral aspects and usage context. For a simple conversion tool, this is acceptable but not comprehensive.
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 doesn't add meaning beyond what the input schema provides, as schema description coverage is 100%. The schema already documents 'amount' and 'decimals' with examples. Since the description doesn't explain parameter interactions or additional context, it meets the baseline score for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: converting formatted amounts to wei using ethers.js. It specifies the verb ('convert'), resource ('formatted amounts'), and technology ('ethers.js'), making it easy to understand. However, it doesn't explicitly differentiate from its sibling 'convert_wei_to_formatted' beyond the directional implication, which keeps 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 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 the sibling tool 'convert_wei_to_formatted' for reverse conversions, nor does it explain scenarios where this conversion is needed (e.g., for blockchain transactions or calculations). Usage is implied only by the tool's name and description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action but lacks details on permissions, rate limits, pagination behavior beyond the schema, or what the output looks like. For a read operation with no annotation coverage, this is a significant gap in transparency.
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 directly states the tool's purpose without unnecessary words. It is appropriately sized and front-loaded, making it easy for an agent to parse quickly.
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 low complexity (one optional parameter) and high schema coverage, the description is minimally adequate. However, with no output schema and no annotations, it lacks details on return values or behavioral traits, leaving gaps that could hinder effective tool invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the single parameter 'page' documented in the schema. The description adds no additional parameter semantics beyond what the schema provides, such as default values or usage context, so it meets the baseline for high schema coverage without compensating 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 verb 'Get list' and the resource 'supported networks on CoinGecko/GeckoTerminal', making the purpose unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'get_supported_chains' or 'get_gasless_chains', which might have overlapping or related functionality, preventing 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 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. Given sibling tools like 'get_supported_chains' and 'get_gasless_chains', there's no indication of differences in scope, source, or use cases, leaving the agent without direction on tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states what the tool does but doesn't describe behavioral traits like whether this is a read-only operation (implied by 'Get list'), potential rate limits, authentication requirements, error conditions, or the format/structure of the returned list. For a tool with zero annotation coverage, this leaves significant gaps in understanding how it behaves.
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 core purpose ('Get list of tokens') and adds necessary qualification ('that support gasless approvals (EIP-2612 permit)'). Every word earns its place, with no redundancy or unnecessary elaboration, making it easy for an agent to parse quickly.
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 (fetching a filtered list), no annotations, no output schema, and 100% schema coverage, the description is minimally adequate. It clearly states the purpose but lacks behavioral context (e.g., response format, pagination) and usage guidelines. The absence of an output schema means the description should ideally hint at return values, but it doesn't, leaving the agent to discover this through execution.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the single parameter 'chainId' fully documented in the schema (including its type, description, and default value). The description adds no parameter-specific information beyond what's in the schema, so it meets the baseline of 3 for high schema coverage. It doesn't compensate for any gaps because there are none 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 action ('Get list of tokens') and the specific resource type ('tokens that support gasless approvals (EIP-2612 permit)'). It distinguishes this tool from siblings like get_token_data or get_token_info by focusing on gasless approval support rather than general token information. However, it doesn't explicitly contrast with get_gasless_chains or get_gasless_status, which are related but different gasless 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 (e.g., needing a chainId for context), compare it to similar tools like get_gasless_chains (which lists chains supporting gasless features) or get_token_data (which provides general token info), or specify use cases (e.g., before executing a gasless swap). The agent must infer usage from the tool name and description alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the action of getting a list, without mentioning any behavioral traits such as whether it's a read-only operation, potential rate limits, authentication needs, or what the output format might be. This leaves significant gaps for an agent to understand how to interact with the tool effectively.
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 directly states the tool's purpose without any unnecessary words. It is front-loaded and appropriately sized for a simple tool, making it easy for an agent to parse quickly.
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 simplicity (0 parameters, no output schema, no annotations), the description is minimal. It lacks details on behavioral aspects like output format or usage context, which are important for an agent to invoke it correctly. While it covers the basic purpose, it doesn't provide enough completeness for reliable tool selection and invocation in a broader context.
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?
The input schema has 0 parameters with 100% coverage, meaning no parameters are documented in the schema. The description doesn't add parameter details, which is acceptable since there are no parameters to explain. This meets the baseline for tools with zero parameters, as it doesn't need to compensate for any 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 verb 'Get' and the resource 'list of blockchain networks supported by Aggregator Protocol', which specifies what the tool does. However, it doesn't distinguish itself from sibling tools like 'get_gasless_chains' or 'get_coingecko_networks', which might also retrieve blockchain-related data, leaving some ambiguity about its unique scope.
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 siblings like 'get_gasless_chains' and 'get_coingecko_networks' that might overlap in retrieving blockchain network information, there is no explicit context, exclusions, or named alternatives mentioned to help an agent choose appropriately.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states this is a read operation ('Get'), but doesn't mention potential limitations like rate limits, authentication requirements, error conditions, or what happens with invalid inputs. For a tool that likely queries external APIs, this lack of transparency is a significant gap.
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 core purpose and provides specific examples of what information is retrieved. Every word serves a purpose with no redundancy or unnecessary elaboration.
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 2 parameters and 100% schema coverage, the description adequately covers the basic purpose. However, without annotations or an output schema, it should ideally mention what the return format looks like (e.g., structured JSON with specific fields) or any notable behavioral aspects given the cryptocurrency/blockchain 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?
The schema description coverage is 100%, with both parameters (network and address) clearly documented in the schema. The description doesn't add any parameter-specific information beyond what's in the schema, such as format examples or validation rules. This meets the baseline expectation 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 clearly states the action ('Get') and resource ('detailed token information') with specific examples of what information is included ('socials, websites, and description'). It distinguishes itself from siblings like get_token_data or get_token_price by focusing on metadata rather than pricing or raw data. However, it doesn't explicitly contrast with all similar 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 like get_token_data, get_token_price, or get_multiple_tokens_data. There's no mention of prerequisites, context, or exclusions, leaving the agent to infer usage based on the tool name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the requirement for quote data but doesn't describe critical traits like whether this is a read/write operation, authentication needs, potential side effects (e.g., funds movement), rate limits, or error handling. This is inadequate for a transaction execution tool.
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 extremely concise with a single, front-loaded sentence that directly states the purpose and key requirement. There is no wasted language, and every word earns its place.
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 complexity of a swap transaction tool with no annotations and no output schema, the description is insufficient. It lacks details on behavioral traits, return values, error conditions, and differentiation from siblings, making it incomplete for safe and effective use 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 schema description coverage is 100%, with the parameter 'quoteData' fully documented in the schema as 'Quote data from get_swap_quote'. The description adds no additional meaning beyond this, so it meets the baseline for high schema coverage without compensating further.
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 action ('Execute a swap transaction') and the resource ('swap transaction'), which is specific and unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'submit_gasless_swap' or 'get_swap_quote', which would be needed for 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 implied usage guidance by mentioning 'requires quote data' and referencing 'get_swap_quote', suggesting this tool should be used after obtaining a quote. However, it doesn't explicitly state when to use this vs. alternatives like 'submit_gasless_swap' or provide clear exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It implies a read-only operation ('Get list') but doesn't disclose behavioral traits such as rate limits, authentication needs, data freshness, or error handling. This is a significant gap for a tool with zero annotation coverage.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It is appropriately sized and front-loaded, with zero waste.
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 (0 parameters, no output schema, no annotations), the description is minimally adequate but lacks depth. It doesn't explain return values (e.g., format of the list) or behavioral context, which is a gap since no output schema exists to compensate.
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?
The tool has 0 parameters, and schema description coverage is 100%, so no parameter information is needed. The description doesn't add param details, but this is acceptable given the absence of parameters, warranting a baseline score of 4.
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 verb 'Get' and the resource 'list of blockchain networks that support gasless swaps', making the purpose specific and understandable. It distinguishes from siblings like 'get_supported_chains' by specifying 'gasless swaps', though it doesn't explicitly contrast them.
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 like 'get_supported_chains' or other gasless-related tools (e.g., 'get_gasless_approval_tokens'). It lacks context on prerequisites, timing, or exclusions, leaving usage unclear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'executable quote' and 'EIP-712 signature data', hinting at a read-only operation that prepares for execution, but fails to clarify if this is a simulation, whether it requires specific permissions, rate limits, or what the output entails (e.g., quote validity, signature details). This leaves significant gaps for a tool with potential transactional implications.
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, front-loaded sentence that efficiently conveys the core purpose without unnecessary words. Every part of the sentence earns its place by specifying key aspects like 'executable', 'gasless', and 'EIP-712 signature data'.
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 complexity of a gasless swap tool with no annotations and no output schema, the description is incomplete. It lacks details on behavioral traits (e.g., safety, side effects), output format, or how the quote integrates with execution tools like execute_swap or submit_gasless_swap. This leaves the agent with insufficient context for proper 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 100%, so the schema fully documents all 6 parameters. The description adds no additional meaning beyond what the schema provides, such as explaining parameter interactions or constraints. With high schema coverage, the baseline score of 3 is appropriate as the description doesn't compensate but also doesn't detract.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Get executable quote') and resource ('for a gasless token swap with EIP-712 signature data'), distinguishing it from sibling tools like get_swap_quote or get_gasless_price by emphasizing the gasless and executable nature with signature data.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives such as get_swap_quote or get_gasless_price, nor does it mention prerequisites like needing a taker address or when gasless swaps are applicable. It lacks explicit usage context or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It mentions 'signing approval and trade messages' and 'no gas fees required', which hints at a mutation operation with specific authentication needs, but it lacks details on permissions, rate limits, error conditions, or what the tool returns (no output schema). This leaves significant behavioral gaps.
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 core action and key benefit ('no gas fees required'). Every word earns its place with no redundancy or unnecessary details.
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 complexity of a swap operation with no annotations and no output schema, the description is incomplete. It doesn't cover return values, error handling, or behavioral nuances like what 'signing' entails or potential side effects, leaving the agent with insufficient context for reliable 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 100%, so the schema already documents both parameters (quoteData and chainId). The description adds minimal value by referencing get_gasless_quote for quoteData, but doesn't explain parameter interactions or usage beyond what's in the schema. Baseline 3 is appropriate given high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('submit a gasless swap') and mechanism ('by signing approval and trade messages'), distinguishing it from sibling tools like execute_swap. However, it doesn't specify what resource is being swapped (e.g., tokens), making it slightly less specific than ideal.
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 when gas fees are undesirable and when quote data is available from get_gasless_quote, but it doesn't explicitly state when to use this tool versus alternatives like execute_swap or provide any exclusions or prerequisites beyond the quote data requirement.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions 'using ethers.js' which hints at library behavior, but doesn't disclose critical traits: error handling (e.g., invalid inputs), output format (string/number), rounding behavior, or performance considerations. For a conversion tool with no annotation coverage, this leaves significant behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero waste. It's front-loaded with the core purpose and includes implementation detail without redundancy. 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?
Given 2 parameters with full schema coverage and no output schema, the description is minimally complete for a simple conversion tool. However, without annotations or output schema, it should ideally explain the return format (e.g., string in ether units) and error cases to be fully helpful.
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 documents both parameters thoroughly. The description adds no additional parameter semantics beyond what's in the schema (e.g., no examples of typical 'amount' values or 'decimals' usage). Baseline 3 is appropriate when 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 verb 'convert' and the resource 'wei amounts to human-readable format', specifying the implementation method 'using ethers.js'. It distinguishes from its sibling 'convert_formatted_to_wei' by indicating the opposite direction of conversion. However, it doesn't explicitly mention what 'human-readable format' means (e.g., ether units).
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 when converting from wei to formatted amounts, with the sibling tool suggesting the alternative for reverse conversion. However, it lacks explicit guidance on when to use this versus other tools for similar purposes (e.g., formatting in different contexts) or prerequisites like valid wei strings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool provides an 'indicative price' (implying non-binding, estimate) and mentions 'no gas fees required', but fails to disclose critical behaviors like whether this is a read-only operation, potential rate limits, authentication needs, or what 'indicative' entails (e.g., time validity, accuracy). This leaves significant gaps for a tool interacting with financial data.
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 core purpose ('Get indicative price') and adds qualifying context ('gasless token swap', 'no gas fees required') without any wasted words. Every element earns its place.
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 6 parameters, no annotations, and no output schema, the description is incomplete. It lacks behavioral details (e.g., read-only status, error conditions), doesn't explain the 'indicative' nature of the output, and provides no guidance on interpreting results. Given the complexity and financial context, more completeness is needed.
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 6 parameters. The description adds no parameter-specific information beyond what's in the schema—it doesn't explain relationships between parameters (e.g., how sellAmount interacts with buyToken) or provide additional context. Baseline 3 is appropriate when schema does all the work.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action ('Get indicative price') for a specific resource ('gasless token swap') and distinguishes it from siblings by emphasizing 'no gas fees required'—differentiating it from tools like get_swap_price or get_swap_quote that likely involve gas fees.
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 ('gasless token swap') but provides no explicit guidance on when to use this tool versus alternatives like get_gasless_quote or get_swap_price. It mentions 'no gas fees required' which hints at a use case, but lacks clear when/when-not instructions 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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It usefully describes performance characteristics ('faster'), data limitations ('no prices/metadata'), and environment variable fallback behavior. However, it doesn't mention rate limits, authentication requirements, error conditions, or what the return format looks like (though there's no output schema).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is perfectly concise - a single sentence that efficiently communicates the tool's purpose, key characteristics (fast, no metadata), and important behavioral detail (env fallback). Every word earns its place with zero redundancy or wasted space.
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 data retrieval tool with no annotations and no output schema, the description provides adequate but incomplete context. It covers the 'what' and 'why' well (purpose and speed trade-off) but lacks details about return format, error handling, or authentication requirements. The 100% schema coverage helps, but behavioral context remains somewhat thin.
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 documents all three parameters thoroughly. The description adds minimal value beyond the schema - it mentions the USER_ADDRESS fallback behavior (already in schema) and implies the tool's focus on speed over completeness. Baseline 3 is appropriate when 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 token balances for wallet addresses' with specific characteristics ('faster, no prices/metadata'). It distinguishes from siblings like get_portfolio_tokens (which likely includes metadata) and get_token_data (which focuses on individual tokens). However, it doesn't explicitly name these alternatives for full 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 clear context about when to use this tool: when you need 'faster' retrieval and don't need 'prices/metadata'. It also explains the fallback behavior ('uses USER_ADDRESS from env if addresses not provided'). However, it doesn't explicitly state when NOT to use it or name specific alternative tools for different use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It mentions the fallback behavior (using USER_ADDRESS from environment), which is useful context. However, it doesn't disclose important behavioral traits like rate limits, authentication requirements, error conditions, or what the response format looks like. For a tool with no annotations and no output schema, this leaves significant gaps.
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 core purpose and includes essential usage guidance. Every word earns its place with no redundancy or unnecessary elaboration. It's appropriately sized 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 5 parameters, no annotations, and no output schema, the description is somewhat incomplete. It covers the basic purpose and fallback behavior but doesn't address what the tool returns, error handling, or other behavioral aspects. For a portfolio tool that likely returns complex data, more context would be helpful despite the good schema coverage.
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 documents all 5 parameters thoroughly. The description adds minimal value beyond the schema - it only mentions the USER_ADDRESS fallback behavior, which is already covered in the schema descriptions for 'addresses' and 'networks'. With high schema coverage, the baseline is 3 even with limited param info in the description.
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 tokens with balances, prices, and metadata for wallet addresses.' It specifies the verb ('Get') and resource ('tokens') with key attributes (balances, prices, metadata). However, it doesn't explicitly differentiate from sibling tools like get_portfolio_balances or get_token_data, which reduces 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 context for when to use this tool: 'uses USER_ADDRESS from env if addresses not provided.' This gives practical guidance on parameter usage. However, it doesn't explicitly state when to choose this tool over alternatives like get_portfolio_balances or get_token_data, 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?
With no annotations provided, the description carries the full burden. It discloses BETA limitations (single address, specific networks) and the fallback to environment variables, which are useful behavioral traits. However, it doesn't cover other important aspects like rate limits, authentication needs, error handling, or what the return format looks like (since there's no output schema).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
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 and includes key constraints. Every part earns its place, though it could be slightly more structured (e.g., separating purpose from limitations).
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 (5 parameters, no annotations, no output schema), the description is moderately complete. It covers the core purpose and key constraints but lacks details on return values, error cases, or deeper behavioral context. The schema handles parameter documentation well, but the description doesn't fully compensate for the absence of annotations and 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?
The schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds minimal value beyond the schema by mentioning the BETA limitation and USER_ADDRESS fallback, which are partially covered in the schema descriptions. It doesn't provide additional syntax, format details, or usage examples beyond what's in the schema.
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 verb ('Get') and resource ('transaction history for a wallet address'), making the purpose specific. It distinguishes from sibling tools like get_portfolio_balances or get_portfolio_tokens by focusing on transactions rather than balances or token holdings.
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 about BETA limitations (1 address, ETH/BASE only) and fallback behavior (uses USER_ADDRESS from env if addresses not provided). However, it doesn't explicitly state when to use this tool versus alternatives like get_portfolio_balances or other transaction-related tools, nor does it mention exclusions.
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:

[![defi-trading-mcp MCP server](https://glama.ai/mcp/servers/edkdev/defi-trading-mcp/badges/card.svg)](https://glama.ai/mcp/servers/edkdev/defi-trading-mcp)

Score Badge

Copy to your README.md:

[![defi-trading-mcp MCP server](https://glama.ai/mcp/servers/edkdev/defi-trading-mcp/badges/score.svg)](https://glama.ai/mcp/servers/edkdev/defi-trading-mcp)

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/edkdev/defi-trading-mcp'

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