SODAX Builders MCP

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already indicate readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds valuable context by specifying that the content includes links to related pages and that it returns complete markdown, beyond what annotations provide. However, it does not mention any caveats like potential size limits or error cases, which would be a minor gap.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is compact and front-loaded, with the primary action stated first. Every sentence contributes purpose, usage context, or relationship to alternatives, with no filler or redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the simple one-parameter interface, the description fully covers what the tool does, how to use it, and what to expect in the output. The lack of an output schema is compensated by the clear statement that it returns full markdown content with links.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema covers 100% of the single parameter, but the description enriches it by specifying that the URL must be a full URL and gives an example. This adds practical meaning beyond the schema's generic 'The URL of the page to fetch'.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool fetches the full markdown content of a documentation page, using the specific verb 'fetch' and identifying the resource. It also distinguishes itself from the sibling tool searchDocumentation, which returns only partial content.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly explains when to use this tool ('when you have a page URL and want to read its content') and contrasts it with searchDocumentation, noting that getPage retrieves the complete page when more details are needed. This provides clear guidance for tool selection.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, covering safety. The description adds a usage-oriented behavioral cue ('Call this first if docs tools seem unavailable') but doesn't disclose what the response contains or how availability is determined, so it adds limited value beyond the annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two concise sentences: the first states the core purpose, the second provides usage guidance. No superfluous words or repetition, and the most important information is front-loaded.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter health check tool, the description fully covers purpose and when to invoke it. Even without an output schema, 'availability' is self-explanatory, and the 'call this first' guidance is sufficient for an agent in context.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has 0 parameters, and schema coverage is trivially 100%. Per the baseline for 0-param tools, a score of 4 is appropriate; the description doesn't need to explain parameters because there are none.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states a specific verb-resource pair ('Check SDK documentation availability') and distinguishes this tool from siblings like docs_list_tools and docs_getPage by framing it as a health check. The added guidance 'Call this first if docs tools seem unavailable' reinforces its diagnostic purpose.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

It explicitly says when to use the tool ('if docs tools seem unavailable') and instructs to call it first, giving clear context. It does not list alternative tools or when-not-to-use, but the trigger condition is unambiguous.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true and openWorldHint=true, so the description does not need to repeat safety information. It adds that the tool lists parameters, which is a useful hint, but does not describe return format or scope in detail. This is minimal added context beyond annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is only two short sentences: the first states the action, the second conveys importance. No filler or redundant content, 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.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple no-parameter listing tool with no output schema, the description adequately covers purpose and usage context. A minor ambiguity exists about which tools are included (only docs_* versus all SDK tools), but the name and sibling context help clarify. Overall complete for its simplicity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, so the schema provides complete coverage. The description correctly omits parameter details, as there are none to explain. Baseline 4 applies for 0-parameter tools.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'List all SDK documentation tools with parameters' uses a specific verb (List) with a clear resource (SDK documentation tools). It distinguishes the tool from data-retrieval siblings by indicating it is a meta-tool for discovering available tools.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The phrase 'Essential for discovering what's available' provides clear context on when to use this tool — during initial exploration. However, it does not explicitly mention alternatives or when not to use it, but for a simple discovery tool this is sufficient.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare idempotentHint=true, readOnlyHint=false, and destructiveHint=false. The description adds the behavior of reconnecting and refreshing available tools, but it does not disclose further behavioral details such as potential side effects, network dependencies, or what 'refresh' entails. With annotations present, the description offers minimal added behavioral transparency, consistent with a 3.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is extremely concise: two sentences that front-load the action ('Reconnect... refresh...') and then provide the use case. Every word earns its place with no redundancy or filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple maintenance tool with no parameters, an existing output schema absent, and annotations covering idempotency and safety, the description fully explains what it does and when to use it. The low complexity means this is complete information.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool accepts zero parameters, and the schema is empty with 100% coverage. The description has no need to explain parameter semantics, and the baseline for zero-parameter tools is 4, so this score is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: to reconnect to SDK documentation and refresh available tools. It uses specific verbs ('reconnect', 'refresh') and names the resource (SDK documentation, available tools), which distinguishes it from siblings like docs_list_tools (which lists tools) and docs_health (which likely checks health).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives explicit guidance on when to use the tool: 'Use if docs seem stale or unavailable.' This provides a clear context but does not explicitly mention alternatives or when not to use it, so it falls short of a 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already establish readOnlyHint=true, openWorldHint=true, and destructiveHint=false. The description adds useful behavioral context by noting the return format: 'The search returns contextual content with titles and direct links to the documentation pages.' This goes beyond the annotations without contradicting them.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two well-structured sentences. The first sentence states the core function and scope. The second provides usage guidance. No filler or redundant content. The '[SDK Docs]' prefix helps with scoping, and every sentence earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple search tool with one required parameter, strong annotations (readOnly, openWorld, non-destructive), and no output schema, the description covers the essential context: what it does, when to use it, and what results it returns. There are no complex edge cases or hidden behaviors that need disclosure.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema has a single parameter 'query' with no description (0% coverage). The description does not explicitly explain what the query parameter should contain, but the tool name and overall description imply it is the search text. Since this is a simple, self-evident parameter, the lack of explicit parameter guidance is a minor gap, hence a mid-range score.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Search across the documentation to find relevant information, code examples, API references, and guides.' The verb 'search' is specific, and the resource (documentation) is unambiguous. It also distinguishes from siblings like docs_getPage by positioning itself as the search tool for documentation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives explicit usage contexts: 'Use this tool when you need to answer questions about Docs, find specific documentation, understand how features work, or locate implementation details.' While it doesn't name alternative tools or when-not-to-use, the contexts are clear enough to guide selection among the docs tool family.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description says 'Report an issue' and 'Send one call per distinct issue,' which implies a write/submission action. However, annotations declare readOnlyHint=true, indicating no side effects. This is a direct contradiction between the description's implied behavior and the annotations, making behavioral transparency critically poor.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-structured and front-loaded with the purpose. It is a bit long but every sentence earns its place, covering usage rules, dedup, and exclusions without fluff.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite the contradiction, the description is extremely complete for a feedback tool: it covers when to use, what constitutes an issue, user reporting, sanity checks, dedup behavior, and exclusions. No output schema is needed for a one-way reporting tool, and the schema handles parameter documentation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema provides 100% coverage with detailed descriptions for all three parameters (goal, content, pageUrl). The main description does not add extra parameter-level meaning beyond what the schema already offers, so the baseline of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Report an issue') and the specific resource ('documentation of Docs'), distinguishing it from sibling tools like docs_getPage and docs_searchDocumentation. It is unequivocal about what the tool does.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides explicit when-to-use guidance ('when you come across content that is outdated, contradictory...' and 'when the user themselves reports a problem'), when-not-to-use ('Do not use this tool to confirm that a page is accurate'), and additional operational rules (one call per issue, no duplicates, sanity check). This is exemplary usage guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description's mention of pagination and the all-assets scope adds useful behavioral context beyond the annotations. It discloses the coverage and pagination behavior effectively.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

One concise sentence that is front-loaded with the primary action and resource. Every word earns its place, with no redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple read-only pagination tool, the description combined with rich schema annotations provides sufficient context. No output schema is needed for a list endpoint, and the scope and pagination are clearly stated.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% with all parameters (limit, format, offset) described. The description does not add parameter details, but the schema already carries the full burden, so the baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a clear verb ('Get'), a specific resource ('all borrowers'), and an explicit scope ('across all money market assets') that differentiates it from sibling tool sodax_get_asset_borrowers. It fully defines what the tool does.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The phrase 'across all money market assets' provides clear context for when to use this tool (when you need borrowers from all assets), but it does not explicitly name alternatives or state when not to use it. This is clear context without explicit exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, covering the safety profile. The description adds useful context about the returned data scope and categories but does not disclose potential limitations like pagination, response size, or rate limits. No contradiction exists.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence that immediately states the action and resource, then lists specific content categories. No filler or redundant phrases; every word adds value.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a read-only configuration retrieval tool with no output schema, the description sufficiently lists the major return categories (contract addresses, RPCs, token configs). The `format` parameter is covered by the schema. However, it does not explain the structure or differences between markdown and JSON output, which would improve completeness.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The single parameter `format` is fully documented in the input schema with an enum, default value, and description. The tool description adds no parameter-specific detail, but because schema coverage is 100%, the baseline score of 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb ('Get') and clearly identifies the resource ('detailed configuration for all spoke chains'), enumerating key content (contract addresses, RPCs, token configs). This distinguishes it from sibling tools such as sodax_get_supported_chains (which likely lists chain IDs only) and sodax_get_all_config (which may be broader or different).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies scope ('all spoke chains') but provides no explicit guidance on when to use this tool versus alternatives, no exclusion criteria, and no mention of sibling tools like sodax_get_all_config or sodax_get_supported_chains. Users must infer usage solely from the name and content list.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, covering the safety profile. The description adds useful scope information by listing what data is returned (chains, swap tokens, protocol settings), but it does not disclose potential response size, structure, or latency. This is a moderate addition beyond the annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence that immediately states the action and resource. Every word adds value, and there is no repetition or filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Since there is no output schema, the description carries the burden of indicating what the tool returns; it lists the major content categories (chains, tokens, protocol settings). It doesn't detail the exact structure, but for a config snapshot tool with no required parameters and a well-covered optional format, this is sufficient. Strong annotations further support completeness.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema fully documents the only parameter 'format' with enum values, default, and description (100% coverage). The tool description adds no parameter-level meaning, so the baseline score of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses the specific verb 'Get' with the resource 'full SODAX configuration' and explicitly enumerates what is included: all supported chains, swap tokens, and protocol settings. This clearly distinguishes it from sibling tools like sodax_get_supported_chains, sodax_get_swap_tokens, and sodax_get_all_chains_configs by signaling an aggregate config snapshot.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The phrase 'in one call' implies a strong usage scenario: retrieving the complete configuration in a single request rather than calling multiple specialized endpoints. However, it does not explicitly state when not to use it or mention alternatives for partial configs, so it has clear context but no exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows it's a safe read. The description adds no additional behavioral context such as pagination, response format, or error behavior. It simply restates the tool's purpose without detailing any side effects or caveats.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, focused sentence that avoids fluff. It is appropriately short, though it could arguably include a bit more context. It is front-loaded and efficient.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the read-only annotations, complete schema, and no output schema, the description is minimally sufficient but lacks usage context and alternative differentiation. It states the resource but does not clarify when to choose this over related getters, making it complete only in a basic sense.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, with detailed descriptions for all six parameters, including enums and defaults. The description itself does not add parameter-level details beyond what the schema already provides, so it meets the baseline of 3.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it retrieves OHLCV candlestick data for an AMM pool, using a specific verb and resource. It distinguishes from sibling tools like get_amm_positions or get_orderbook by focusing on chart/candle data.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description offers no guidance on when to use this tool over alternatives. It does not mention any prerequisites, use cases, or exclusions. Sibling tools exist but no differentiation is provided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is known. The description adds the owner filter detail, but that is also in the schema. It doesn't disclose extra behavioral aspects like pagination behavior or rate limits, which is acceptable given the annotations cover the key safety traits.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence that conveys the essential purpose and the optional filtering capability. Every word earns its place; there is no redundancy or unnecessary detail.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a read-only list tool with 4 optional parameters and a clear schema, the description is sufficient. It doesn't describe return values, but no output schema exists and the purpose is straightforward. The description, combined with annotations and schema, gives an agent enough context to invoke the tool correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema description coverage is 100%, with each parameter (limit, owner, format, offset) having a clear description. The tool description itself does not add semantic meaning beyond the schema, so a baseline score of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states a specific verb ('Get') and resource ('AMM liquidity provider NFT positions'), and immediately distinguishes itself from sibling tools like 'sodax_get_user_position' by specifying the AMM context. The optional owner filter is also mentioned, which adds clarity.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description gives clear context: use to retrieve AMM NFT positions, with an optional owner filter. It doesn't explicitly name alternatives or exclusion cases, but the owner filter and the resource specificity provide enough guidance for tool selection among the many 'sodax_get_*' siblings.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the tool's non-mutating behavior is covered. The description adds no additional behavioral context beyond what the annotations and schema already provide, such as pagination details or response characteristics.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, concise sentence that front-loads the action and resource. No wasted words, and it is appropriately sized for the tool's simplicity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple read-only list tool with comprehensive schema coverage and annotations, the description adequately conveys the core purpose. It could mention pagination, but the schema already documents limit/offset, so the description is sufficient.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so all parameters are fully documented. The description only restates the reserve address role without adding new semantics beyond the schema's own descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states a specific verb ('Get') and resource ('borrowers for a specific money market asset'), and identifies the key parameter ('reserve address'). It distinguishes itself from sibling tools like sodax_get_all_borrowers (all borrowers) and sodax_get_asset_suppliers (different resource type).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for a single asset via 'specific money market asset' but does not explicitly state when to use this tool versus alternatives such as sodax_get_all_borrowers. There is no direct when/when-not guidance, but the phrasing gives a reasonable hint.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the agent knows it's a safe read. The description adds minimal extra behavior—just the scoping by reserve address, which is also in the schema. No additional context about pagination or output format beyond schema.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Single sentence, no fluff. Front-loaded with verb and resource. Excellent for a simple read tool.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple read-only tool with no output schema, the description plus annotations and schema fully cover the agent's needs. It could slightly improve by hinting at return format, but the schema already covers format and limit/offset.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so all parameters have descriptions. The description mentions 'reserve address' but doesn't add any semantic detail beyond the schema. Baseline of 3 is appropriate when schema handles parameter documentation.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Get suppliers'), the resource ('money market asset'), and the key parameter ('reserve address'). It distinguishes from siblings like sodax_get_asset_borrowers by explicitly mentioning lenders/suppliers.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The context is clear: use this tool when you need the list of suppliers/lenders for a specific money market asset. It doesn't explicitly name alternatives or exclusions, but the purpose is unambiguous.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already indicate a safe read operation. The description adds that the result is a plain number, which is useful behavioral context regarding the return format. No misleading information.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single sentence with no filler, perfectly sized for the tool's simplicity. Every word earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the simple tool with one optional parameter and no output schema, the description adequately conveys purpose and return type. No missing context noted.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema fully documents the single optional format parameter with enum and description. The tool description adds no parameter-specific meaning beyond that, so the baseline 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly identifies the action (Get), the specific resource (SODA token circulating supply), and the output format (plain number), distinguishing it from sibling tools like sodax_get_total_supply.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives such as sodax_get_total_supply or sodax_get_token_supply. The description only states what it does without any context for selection.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds behavioral context by explaining that the assets represent spoke tokens and that filtering by source chain is optional. This goes beyond the schema and helps set expectations about the returned data, though it does not dive into pagination or output details.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, compact sentence that conveys the core purpose and the main optional behavior. It is front-loaded with the verb and resource, and every word contributes to understanding. No fluff or redundant information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool is a simple read operation with two optional parameters and no output schema. The description provides enough semantic context (hub chain, spoke tokens, filter) for an agent to understand what the tool does and what to expect. While it doesn't describe the return structure, the simplicity and annotations make it adequate. A 5 would require more detail (e.g., default behavior when no filter is given), but 4 is reasonable.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%: both 'format' and 'chainId' are fully documented in the input schema, so the description need not elaborate. The description's phrase 'optionally filtered by source chain' aligns with the chainId parameter but does not add new meaning beyond the schema. Baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's function: 'Get assets representing spoke tokens on the hub (Sonic) chain'. This uses a specific verb ('Get') and a distinct resource ('assets representing spoke tokens on the hub chain'), which distinguishes it from sibling tools like get_swap_tokens or get_money_market_assets. The optional source-chain filter is also mentioned, adding precision.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage context: use this tool when you need assets on the hub (Sonic) chain that represent spoke tokens, optionally filtering by source chain. It does not explicitly list alternatives or when-not-to-use, but the context is clear enough for an agent to select it over siblings. No exclusions are provided, but none are necessary.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true, destructiveHint=false, and the description's 'look up' aligns with that. It adds little beyond the annotation, but it does clarify the operation is a lookup, not a mutation. No additional behavioral details (e.g., response format, rate limits) are provided, but the annotation covers the safety profile.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence that delivers the core purpose and key distinction without extraneous words. Every word earns its place, 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.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple read-only lookup tool with complete schema and annotations, the description is adequate. It covers the essential input (intent hash) and distinguishes from transaction hash. With no output schema, the agent may not know the exact return shape, but the description's clarity and schema richness make this a minor gap, not a critical omission.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%: both 'intentHash' (66-char hex string with 0x) and 'format' (enum with default) are well-described. The description adds no additional parameter meaning beyond what the schema already provides, so the baseline score of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses the specific verb 'look up' with a clear resource ('a specific intent') and identifies the key parameter 'intent hash'. It explicitly distinguishes from a transaction hash, differentiating this from sibling tools like sodax_get_transaction, making the purpose unmistakable.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description clearly implies when to use this tool: when you have an intent hash, not a transaction hash. It provides an explicit exclusion ('different from transaction hash') which guides tool selection, though it does not name alternative tools directly.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The annotations already declare readOnlyHint=true and destructiveHint=false, establishing a safe read operation. The description does not contradict these and adds the scope of retrieving by reserve address, but it does not disclose additional behavioral traits such as response format defaults or potential external calls.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence that is front-loaded with the action and resource, containing no redundant or extraneous wording. It is efficient and easy to parse.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool is a simple read-only lookup with good annotations and clear parameter schema, but the description does not specify what 'detailed information' contains or how the format parameter affects output. Without an output schema, the agent may need to probe the tool to understand the return structure.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, and the description's 'by its reserve address' aligns with the reserveAddress schema property. The format parameter is fully documented with an enum and default in the schema, so the description adds little beyond what is structurally available.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses the verb 'Get' with a specific resource 'detailed information for a specific money market asset' and identifies the lookup key 'by its reserve address'. This clearly distinguishes it from sibling list tools like sodax_get_money_market_assets and sodax_get_money_market_reserve_assets, which retrieve collections rather than a single asset.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage when a user has a reserve address and wants details for that asset, but it does not explicitly state when to prefer this tool over alternatives or provide exclusions. There is no mention of when to use this vs sodax_get_money_market_reserve_assets or sodax_get_money_market_tokens.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true and destructiveHint=false, covering safety. The description adds the behavioral scope of 'available for lending and borrowing', which is useful context, but it does not mention response format, pagination, or any edge cases, leaving some behavior undisclosed.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence that immediately states the action ('List') and the object ('all assets'). It contains no redundant words and is easy to parse.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the large number of sibling tools with overlapping names (e.g., 'get_money_market_reserve_assets', 'get_money_market_tokens', 'get_hub_assets'), the description is vague about what constitutes an 'asset'. There is no output schema and no mention of response structure, so the agent may not know what fields to expect.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%: both 'format' and 'chainId' have clear descriptions. The tool description adds no additional parameter semantics, so the score remains at the schema-covered baseline of 3.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses the specific verb 'List' with a clear resource and scope: 'all assets available for lending and borrowing in the SODAX money market'. This distinguishes it from sibling tools like 'sodax_get_money_market_asset' (singular) and 'sodax_get_money_market_reserve_assets', making the purpose unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description clearly states the tool's scope (list all lendable/borrowable assets), implying when to use it. However, it does not explicitly contrast with alternatives or state when not to use it, such as when a specific asset or reserve assets are needed.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already indicate readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds only domain context ('used as collateral backing') and does not disclose additional behavioral traits such as response format, pagination, or rate limits. Since annotations cover the basics, the description is minimally sufficient.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence with no filler words. It is appropriately concise, though slightly terse and could have benefited from one additional clause about output context.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple one-parameter read-only tool with good annotations and schema coverage, the description provides the core action. However, it does not explain what the returned assets look like or how they relate to other money market concepts, and there is no output schema to compensate. It is minimally adequate but leaves some ambiguity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The only parameter 'format' is fully described in the schema with enum values and a clear explanation ('json' vs 'markdown'). The tool description adds no extra parameter semantics, so the baseline of 3 applies due to high schema coverage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool retrieves 'money market reserve assets used as collateral backing', using a specific verb and resource. It distinguishes from sibling tools like sodax_get_money_market_assets by the 'reserve assets' and 'collateral backing' qualifiers, though it doesn't explicitly differentiate in a contrastive way.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no explicit guidance on when to use this tool versus alternatives, nor does it mention conditions, exclusions, or related tools. Sibling tools are numerous, but no context is given for selecting this one.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare the tool as read-only and non-destructive. The description adds the optional chain-filtering behavior, but does not disclose additional traits such as response format, pagination, or rate limits. It aligns with annotations without contradicting them.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, well-structured sentence that starts with the action verb and contains no fluff. It is front-loaded and easy to parse.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple tool with two optional parameters and no output schema, the description adequately covers the purpose and filter. A minor gap is the lack of differentiation from similarly named siblings, but given the low complexity, the description is largely complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema provides 100% description coverage for both parameters ('format' and 'chainId'), so the description does not need to add much. It only restates the chain filter option, adding no new meaning beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose with a specific verb ('Get') and resource ('tokens supported for money market lending/borrowing'), plus an optional filter ('by chain'). It distinguishes from sibling tools like sodax_get_swap_tokens by focusing exclusively on money market tokens.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The usage context is implied: use when you need tokens for money market lending/borrowing. However, no explicit guidance is given on when to choose this over similar tools like sodax_get_money_market_assets, and no exclusions or alternatives are mentioned.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds that entries are 'pending/open intents', providing some behavioral context. However, it does not disclose pagination behavior, default response format, or how the orderbook is scoped, though the schema largely covers parameters.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence with no redundant words. It succinctly states the tool's purpose without repeating schema or annotation information, demonstrating excellent conciseness.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has 11 optional parameters and no output schema, the one-sentence description is functional but minimal. It does not mention that filters are available, that the default response format is markdown, or how to retrieve a specific intent for more detail. The 'pending/open intents' phrase adds some value but leaves gaps for richer context.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, meaning all 11 parameters already have descriptive text in the schema. The tool description adds no additional parameter semantics beyond what the schema provides, so the baseline score of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb 'Get' with the resource 'current orderbook entries' and clarifies 'showing pending/open intents'. This clearly distinguishes it from sibling tools like sodax_get_intent, which likely retrieves a single intent, and other generic get_* tools.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description offers no guidance on when to use this tool versus alternatives. It lacks any mention of prerequisites, exclusions, or context where another tool (e.g., sodax_get_intent) would be more appropriate. The only usage signal is the tool name itself.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds content context (the list includes wallets, DEXs, and protocols) but does not disclose additional behaviors such as response size, pagination, or the effect of the chainId filter. With annotations present, this is acceptable but not enriched.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, clear sentence that front-loads the verb and resource, then provides illustrative examples. There is no redundant or filler content.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple read-only listing tool with two optional parameters and no output schema, the description plus the schema provides enough context to understand what the tool does and how to invoke it. However, it could be more complete by referencing related tools or explaining the meaning of 'all' in a multi-chain context.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%: both 'format' and 'chainId' have descriptions that meaningfully explain their purpose. The tool description adds no additional parameter semantics, so the baseline score of 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses the specific verb 'List' and identifies the resource as 'SODAX integration partners,' with concrete examples ('wallets, DEXs, and other protocols'). It clearly distinguishes from sibling tools like sodax_get_partner_summary by indicating it returns all partners rather than a single summary.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for retrieving a complete list of partners, but it does not explicitly state when to use this tool over alternatives or mention exclusions. For example, there is no advice to use sodax_get_partner_summary for details on a specific partner. This is adequate but lacks explicit guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already indicate readOnlyHint=true and destructiveHint=false, so the description aligns with a safe read operation. It adds the high-level output ('volume and activity summary') but does not describe the response format, data granularity, or any limitations. Given the annotations, some credit is earned, but the description itself is not behaviorally rich.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, focused sentence with no fluff. It efficiently conveys the core action and target. However, 'activity summary' is somewhat vague and could be more explicit about the content, which would improve clarity without adding much length.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool has simple parameters and clear annotations, but no output schema. The description gives a high-level indication of the return (volume and activity summary) but lacks detail about the format, field names, or how chainId filtering affects results. Compared to many similar sibling tools, this description does not fully differentiate the tool's specific use case, leaving some ambiguity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so all parameters have descriptions. The description adds no semantic value beyond restating 'receiver address', while format and chainId are already explained in the schema. Baseline 3 is appropriate because the schema carries the informational weight.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool gets a volume and activity summary for a specific integration partner, identified by receiver address. This is a specific verb+resource+scope and distinguishes it from sibling tools like sodax_get_partners (which lists partners) and sodax_get_volume (which likely aggregates volumes).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies it is for querying one partner's summary but does not explicitly contrast with alternatives or state when not to use it. For example, it does not say 'use sodax_get_partners for a list of all partners' or 'use sodax_get_volume_stats for global stats'. The usage context is understandable but not fully guided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, covering the safety profile. The description adds no further behavioral details such as return format, pagination, or error behavior. It does not contradict annotations, but it offers minimal extra context beyond purpose.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, concise sentence (12 words) with no filler. It is front-loaded with the 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.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple read-only get tool with one optional parameter and no output schema, the description is sufficiently complete. It clearly states what is retrieved and the associated network context. Although the return structure isn't described, the tool's purpose is self-explanatory for the intended use case.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% description coverage for the only parameter 'format', including its enum values and default. The tool description does not add additional meaning about parameters, relying on the schema. This matches the baseline for high schema coverage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states a specific verb ('Get') and a specific resource ('mapping between chain IDs and intent relay chain IDs used by the SODAX relay network'). It distinguishes itself from sibling tools by focusing on the relay chain ID mapping, which is a unique function.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage context via 'used by the SODAX relay network', but does not explicitly state when to use this tool over other sodax_get_* tools, nor does it mention exclusions or alternatives. It relies on the tool's name and description for inference.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the description's job is lighter. It adds useful context by specifying 'solver-side details' and 'fill history,' plus the includeAll behavior, which clarifies what the tool returns without contradicting the safety annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences long, front-loaded with the primary purpose, and contains no filler. Every word contributes to understanding the tool's core function.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

This is a straightforward read-only lookup tool with a fully documented schema and safety annotations. The description adequately covers the tool's scope; an output schema is absent but not critical here since the purpose and available options are clear.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema has 100% coverage with clear descriptions for all three parameters (intentHash, format, includeAll). The description only rephrases includeAll's effect ('all solver documents') without adding new semantic meaning, so it does not improve on the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states 'Get solver-side details for an intent including fill history,' using a specific verb and resource. The phrase 'solver-side' distinguishes this from the sibling tool sodax_get_intent, which likely returns general intent data.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No explicit guidance is given about when to use this tool versus alternatives like sodax_get_intent. The only usage hint is 'Use includeAll to see all solver documents,' which is parameter-specific, not tool-selection guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond the readOnlyHint annotation, the description discloses significant behavioral caveats: bridged tokens may be 'priced but frequently return 'No path was found'', and routability depends on pair/amount/liquidity. It also explains the difference between being listed/priced and being routable, which is not implied by annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is front-loaded with the primary purpose, then offers targeted usage details and caveats. Each sentence provides essential information—no fluff or repetition. It is compact relative to the wealth of behavioral context it conveys, making it highly scannable.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a read-only getter with optional filters, the description covers the tool's purpose, the intended use case for quoting, a crucial caveat about routability, and the relationship with sibling tools. There is no output schema, but the data type (USD prices per chain/token) is implicitly clear from the description, making it complete for an agent to invoke correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% for all three parameters, giving a baseline of 3. The description adds meaningful context for chainId by explaining the '146' filter and its significance for the quote service compatibility check. It also provides an example symbol ('SODA') that reinforces the symbol parameter's semantics, adding value beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description starts with a clear action: 'Get the solver's oracle USD prices per (chain, token)'. It specifies the resource (solver's oracle USD prices) and scope (per chain/token), which distinguishes it from siblings like sodax_get_solver_quote. The next sentence explicitly differentiates it from quoting use cases, ensuring no confusion.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides explicit usage guidance: 'For quoting with sodax_get_solver_quote, filter chainId='146'' and explains the compatibility check. It also notes when it is useful for sanity-checking quote amounts. It does not explicitly state when-not-to-use, but the alternative tool is named and the context is unambiguous.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true, openWorldHint=true, destructiveHint=false, but the description adds significant behavioral context: two distinct HTTP-400 failure modes with exact messages and causes, pair/amount/liquidity-dependent routing, and the observation that some oracle-priced tokens have no route. This exceeds what annotations provide.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is long but every sentence earns its place: it is front-loaded with the core action, then organized into example, quoteType explanation, failure modes, and token-selection guidance. No redundant or filler content; structure supports quick scanning.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given 5 parameters, no output schema, and moderate complexity, this description is exceptionally complete. It explains the return value (quoted_amount), how to interpret quoteType, error handling for both common failures, and provides concrete examples. The user can confidently invoke the tool without needing external documentation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Although the schema covers 100% of parameters, the description adds substantial meaning: it provides a working example address pair, explains exact_input vs exact_output semantics, warns that very large amounts can fail, and elaborates on token selection (wrapped/derivative tokens often unroutable). This goes beyond the schema's basic descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a specific verb and resource: 'Get a swap quote from the SODAX solver.' It clearly distinguishes this from sibling tools by immediately directing the user to sodax_get_solver_oracle for address lookup, and by focusing on quote generation for swaps rather than intents, tokens, or oracle prices.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides explicit, actionable when-to-use guidance: addresses must be hub-chain chainId-146 assets, use sodax_get_solver_oracle, and prefer canonical bridged *_ASSET tokens. It also tells users what to do on failure (retry with smaller amount or more liquid counterparty) and when not to use certain tokens. This is far beyond a generic usage note.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is known. The description adds context about the use case (cross-chain swaps and DeFi) but doesn't disclose any additional behavioral traits like output structure or potential caching.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single, efficiently worded sentence that is front-loaded with the key action ('List all blockchain networks'). No unnecessary words or repetition.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple tool with one optional parameter and no output schema, the description is largely sufficient. The main gap is the lack of differentiation from similar sibling tools, which could lead to selection confusion in an agent context.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, with the single 'format' parameter fully described in the schema. The description adds no additional parameter semantics, so the baseline of 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool lists all supported blockchain networks, with a specific verb and resource. However, it doesn't differentiate from sibling tools like sodax_get_all_chains_configs, which could be confused for a similar list operation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives such as sodax_get_all_chains_configs or sodax_get_relay_chain_id_map. The description only states what it does, not when to prefer it.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true and destructiveHint=false, covering safety. The description adds the optional chain filter, but this is also present in the schema. No additional behavioral context (e.g., rate limits, meaning of 'available') is provided.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single 13-word sentence that is front-loaded with the core purpose. Every word earns its place; no unnecessary filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple read-only list tool, the schema and annotations supply enough context. The description lacks specifics about default behavior when no chainId is given and does not explain what 'available tokens' entails, but the overall definition is adequate.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so baseline is 3. The description does not add any parameter details beyond what the schema already provides; the schema descriptions for chainId and format are thorough.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it retrieves available tokens for swapping on SODAX, with an optional chain filter. This specific verb+resource combination distinguishes it from sibling tools like money market getters.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. While the schema's chainId parameter mentions calling sodax_get_supported_chains, that is for parameter values, not tool selection.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare read-only and non-destructive behavior, so the description's additional mention of total, circulating, and burned amounts provides some behavioral context beyond the name. It does not describe return format or side effects, but with annotations covering safety, this is acceptable.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, focused sentence that front-loads the verb and resource with no filler. Every word contributes meaning, and it is appropriately sized for the tool's simplicity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity (one optional parameter, no output schema, annotations present), the description covers the core purpose. However, it does not clarify the relationship to overlapping sibling tools, which could lead to incorrect selection. The lack of output structure details is mitigated by the schema, but sibling ambiguity prevents a higher score.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The only parameter, 'format', is fully described in the schema with enum values and a default. The tool description adds no additional parameter meaning, and with 100% schema coverage, the baseline of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool retrieves SODA token supply information, explicitly listing total, circulating, and burned amounts. This gives a specific verb and resource, though it does not distinguish itself from sibling tools like sodax_get_circulating_supply or sodax_get_total_supply.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus the more specific sibling tools for circulating supply or total supply. The description implies general use but does not mention alternatives or exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds the output format note ('as a plain number'), which is helpful but does not disclose other behavioral traits. Given the simple read-only nature, this is adequate.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, front-loaded sentence with no unnecessary words. It effectively communicates the tool's purpose and return type.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a read-only, single-parameter tool, the description is sufficient. It clarifies the supply type and output format, which is especially useful since no output schema is provided. The name and description together make the tool self-explanatory.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema fully describes the optional 'format' parameter with enum values and default. The description does not add further parameter meaning. With 100% schema coverage, baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool retrieves the SODA token total supply and specifies the output as a plain number. The term 'total supply' distinguishes it from sibling tools like sodax_get_circulating_supply, though it doesn't explicitly name them.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

No usage guidance is provided. The description does not indicate when to use this tool versus alternatives such as sodax_get_circulating_supply or sodax_get_token_supply, leaving the agent to infer from the name.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds that the response includes status, amounts, and details, which is useful but does not disclose additional behaviors like response format defaults or error cases.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, concise sentence that communicates the tool's core function without unnecessary words. All information is front-loaded and earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple lookup tool with high schema coverage and safe-read annotations, the description provides enough context to select and invoke correctly. It does not detail the exact return structure, but the mention of status, amounts, and details gives a reasonable expectation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema covers both parameters with descriptions (txHash with example, format with enum and default). The description aligns with the schema but does not add further meaning beyond what is already provided, so the baseline score of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool looks up a specific transaction by hash to see status, amounts, and details. It distinguishes from sibling tools like sodax_get_user_transactions by emphasizing a single transaction lookup via hash.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The phrase 'a specific transaction by its hash' provides clear context for when to use this tool, but it does not explicitly mention alternatives or when not to use it. This is sufficient for a straightforward lookup tool.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, covering the safety profile. The description adds no extra behavioral details such as return format quirks, pagination, or what 'position' includes, but the annotations lower the bar and the description aligns with them.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, focused sentence that immediately communicates the tool's function without any filler or redundancy. It earns its place perfectly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple getter with well-defined parameters and safety annotations, the description is sufficiently complete to guide invocation. There is no output schema, but the tool conceptually returns a position; the description doesn't detail the return structure, but this is a minor gap for such a straightforward lookup.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema fully describes both parameters (userAddress and format) with clear descriptions, and says format has enum json/markdown. With 100% schema coverage, the description adds no parameter information, so baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool gets a user's lending and borrowing position in the money market, with a specific verb ('get') and resource ('user position'). It distinguishes from sibling tools like get_user_transactions (transactions not positions) and get_asset_borrowers (asset-level, not user-level).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies the tool should be used when you need a specific user's money market position, but does not explicitly name alternatives or exclusions. The context is clear enough for an agent to select it over sibling tools, but it lacks explicit 'use this instead of X' guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already establish readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds the semantic of 'history' (multiple entries) and wallet filtering, but does not disclose pagination behavior, data ordering, or response structure beyond what the schema presents. With annotations present, this is adequate although not rich.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, focused sentence that communicates the core purpose without unnecessary verbosity. It is front-loaded and every word earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple historical lookup tool with detailed schema and annotations, the description provides sufficient context. However, it does not clarify what distinguishes 'intent' from 'transaction' or state that the result is a list, though the format parameter and sibling tool names partially cover this. Overall, the description is complete enough for the tool's complexity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema covers 100% of the parameters with descriptions, including limit, format, offset, fromBlock, toBlock, and userAddress. The description adds no parameter-level detail beyond the schema, so the baseline score of 3 applies.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action (Get), the resource (intent/transaction history), and the scope (specific wallet address). It distinguishes itself from sibling tools like sodax_get_intent or sodax_get_transaction by specifying a history-oriented, wallet-scoped lookup.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage when needing transaction history for a wallet, but does not explicitly discuss alternatives or when not to use it. Sibling tools are not referenced, so the guidance is implicit rather than explicit.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds usage constraints (required tokens, block/time range exclusivity) and mentions pagination, providing context beyond the safety annotations without contradicting them.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two concise sentences with no filler, front-loading the main purpose and immediately following with usage essentials.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With 15 parameters and no output schema, the description provides a solid high-level overview—purpose, required fields, filter groups, and mutual exclusion. However, it omits details like response format (covered by the format parameter in the schema) and pagination cursor mechanics, which are described in the schema. Overall, the description is sufficient given the rich schema.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the baseline is 3. The description adds value by grouping parameters into required (inputToken, outputToken) and optional filters (chain, solver, block range OR time range) and explicitly restating the 'don't mix' constraint, which aids the agent's selection.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly identifies the tool as a read-only query for solver volume data, specifying it returns 'filled intents' and supports 'filtering and pagination.' This distinguishes it from sibling tools like sodax_get_volume_stats and sodax_get_solver_intent.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Provides explicit usage constraints: 'Requires inputToken and outputToken,' identifies optional filters, and warns against mixing block and time ranges ('don't mix both'). However, it doesn't name alternative tools or state when not to use this tool.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond the readOnlyHint annotation, the description discloses that the data is cached ~60s upstream and is approximate, which is critical for interpreting freshness and precision. This adds meaningful behavioral context beyond what annotations already convey.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two compact sentences, front-loaded with the primary purpose. The second sentence adds essential nuance about the metric and caching without unnecessary filler. Every clause contributes value.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple read-only getter with one optional parameter and no output schema, the description sufficiently specifies the return value ('approximate total number...') and key behavioral traits. No critical information is missing for correct invocation and interpretation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% for the single optional 'format' parameter, so the baseline is 3. The description does not add additional parameter semantics, but the schema fully explains the parameter's purpose and enum values.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's function: 'Get aggregate solver volume stats' with a specific metric definition ('approximate total number of filled-intent records'). It also distinguishes the metric from a potentially related sibling ('not distinct intents'), effectively disambiguating from other volume tools.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides clear context for when to use this tool: when aggregate solver volume stats (specifically fill documents) are needed. However, it does not explicitly name alternatives or exclusions, though the clarification about 'filled-intent records, not distinct intents' helps guide selection relative to sibling tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description states which caches are cleared and that it reports the number of entries cleared per cache. It does not contradict the annotations (readOnlyHint=false, idempotentHint=true, destructiveHint=false). It adds value beyond annotations by specifying the exact caches affected and the reporting behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, concise sentence that conveys all necessary information without redundancy. Every clause earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a zero-parameter cache-clearing tool, the description fully covers what it does, which caches are affected, and what the output will be (number of entries cleared). No output schema exists, but the description accounts for that by describing the return behavior. No important context is missing.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, so parameter semantics are trivially handled. Baseline 4 is appropriate because the description does not need to compensate for any schema gaps.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool clears two specific caches (backend API cache and solver oracle cache) to force fresh fetches. This is a specific verb+resource combination that distinguishes it from the many get_ tools in the sibling list, which are read-only operations.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies when to use the tool ('to force fresh fetches on next requests'), providing clear context for its intended use. However, it does not explicitly mention when not to use it or name alternative tools, though no sibling seems to offer equivalent cache-clearing functionality.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds the failure return shape ({success:false, message}) which is useful, but does not disclose other behaviors such as error handling, rate limits, or any nuances of the packet lookup. It doesn't contradict annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences, front-loaded with the primary action and outcome. Every sentence earns its place, with no fluff or redundant information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple read tool with fair annotations, the description explains the core function and success/failure response. However, it omits the required chainId and txHash parameters and how they relate to conn_sn, which is important for correct invocation. Since there is no output schema, a bit more detail about the returned packet structure would improve completeness, but it's adequate overall.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already provides detailed meaning for all four parameters. The description's mention of conn_sn adds no new semantic value beyond the schema. There is a notable inconsistency: the description of connSn says 'REQUIRED' but the schema required list only includes chainId and txHash, which could confuse agents about mandatory parameters.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb ('Fetch') and clearly identifies the resource ('a single relay packet') and the selection key ('connection serial number'). It distinguishes from the sibling tool sodax_relay_get_transaction_packets by being singular, and mentions the return shape, making the purpose unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies that only conn_sn is needed to fetch a packet, but the schema lists chainId and txHash as required. This is misleading and provides no explicit guidance on when to use this tool versus sodax_relay_get_transaction_packets. There are no exclusions or alternative recommendations.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true and openWorldHint=true, and the description adds meaningful behavioral context by explaining how to interpret packet completeness (status='executed' and dst_tx_hash populated). This goes beyond the structured annotations without contradicting them.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences, front-loaded with the core purpose, and each sentence earns its place. The first defines what the tool does; the second explains the use case and success criteria. No redundant or vague text.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity (read-only list, three parameters with thorough schema descriptions, no output schema), the description adequately covers purpose, usage, and result interpretation. It could mention potential large result sets or pagination, but that is not essential for this low-complexity tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, with each parameter (chainId, txHash, format) already fully described in terms of meaning and defaults. The description adds no new parameter-level semantics, so the baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb ('List') and resource ('every cross-chain packet emitted by a given source transaction'), clearly distinguishing it from sibling tools like sodax_relay_get_packet (which likely targets a single packet) and other get_ tools. The scope is explicit and actionable.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Provides explicit use-case guidance: 'Use this to track relay status' and defines a clear completion criterion. It does not explicitly name alternatives or when-not-to-use, but the focused wording and sibling structure imply this tool is for packet enumeration while sodax_relay_get_packet handles single-packet lookups.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare idempotentHint=true and destructiveHint=false, and the description complements this by explicitly stating that re-submitting is a no-op and that the transaction must be finalized. It adds the prerequisite of source-chain finalization, which is not implied by the annotations. This is beyond the annotations, though it does not describe error handling or side effects on the destination chain.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is three concise sentences, front-loaded with the primary purpose, followed by a critical prerequisite and a specific edge case. Every sentence adds meaningful information without redundancy, making it easy to parse quickly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (nested object, no output schema), the description covers the essential aspects: purpose, prerequisite, idempotency, and split-tx handling. It omits details about the response format or error behavior, but the `format` parameter hints at response types. Overall, it is sufficiently complete for an agent to invoke correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, with rich parameter descriptions for chainId, txHash, data, and format (including examples and a pointer to the chain ID map). The description adds marginal value by calling out `data` as optional and required only for split-tx chains, which is already in the schema. Since the schema handles the heavy lifting, the baseline of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb 'Submit' and identifies the resource as 'confirmed spoke-chain transaction to the SODAX intent relay' with a clear goal ('delivered to the destination chain'). It distinguishes this from sibling tools, which are predominantly read-only queries or relay packet retrieval, by being the only submission tool.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides clear usage context: the transaction must be finalized on the source chain, and it notes the no-op behavior for re-submissions. It also specifies when to include the optional `data` argument (split-tx chains). While it doesn't explicitly name alternative tools, the context is sufficient for an agent to know when to invoke this tool.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.