SAP MCP Server

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

Annotations already indicate destructiveHint=true, and the description adds context with 'operation class write' and a note to confirm before writes. It also includes a nuanced guideline about pairing with SAP registry metadata, which adds transparency 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 contains multiple sentences, including a somewhat redundant listing of flows and a guideline sentence. It could be more concise by merging related information, but is not overly verbose.

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 existence of an output schema and high schema coverage, the description provides sufficient context for an agent to understand when and how to use the tool. It includes confirmation prerequisites and pairing notes, though does not detail all behavioral side effects.

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?

Input schema coverage is 100% with descriptions for both parameters. The tool description does not add new semantic information beyond what the schema provides, meeting the baseline expectation.

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 'Purchase an NFT from a 3.Land listing,' using a specific verb and resource. It distinguishes from sibling tools like 3land_listForSale and 3land_cancelListing by focusing on purchase, and provides context for the overall flow.

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 mentions use in a set of flows but does not explicitly state when to use this tool versus alternatives. It gives a guideline to confirm before writes, but lacks clear when-not-to-use guidance or comparison with 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?

Annotations already indicate destructive hint. Description confirms write operation and need to confirm state, but does not add 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?

Four sentences, first is direct. Some generic SAP context adds length but not much value. Adequately concise.

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 output schema and full param coverage, description is minimally complete. Could mention what happens on success, failure reasons, or idempotency if already cancelled.

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 covers both parameters fully (100% description coverage). Description adds no extra meaning to 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?

Clearly states 'Cancel an active NFT listing on 3.Land.' verb+resource, distinct from sibling tools like 3land_listForSale.

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 context for the flow (collection, minting, listing, cancellation) and advises confirming state before writes, but lacks explicit when-to-use vs alternatives.

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 indicate readOnlyHint=false, idempotentHint=false, destructiveHint=false. The description adds redundant 'operation class write' and offers a pre-check recommendation, but does not disclose potential side effects, permission requirements, or behavior 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?

The description is three sentences long, starting with the core purpose. The inclusion of SAP MCP context is somewhat extraneous but not overly verbose. The structure is reasonably 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?

With an output schema present, the description does not need to explain return values. It covers the basic usage context and includes a pre-check reminder. However, it lacks details on prerequisites (e.g., wallet setup) and does not address the full scope of parameters or potential errors.

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, so the schema fully documents each parameter. The description does not provide additional semantic information about parameters beyond listing required fields. 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 'Create a new NFT collection on 3.Land marketplace.' This is a specific verb+resource combination that distinguishes it from sibling tools like 3land_buyNFT, 3land_cancelListing, etc., which handle different 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 provides general context: 'Use for 3.Land NFT collection, minting, listing, cancellation, and purchase flows.' It advises to confirm marketplace conditions before writes. However, it does not explicitly state when to use this tool versus alternatives, nor does it give clear exclusions or prerequisites.

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 'operation class write' but annotations include 'readOnlyHint: true', which is a direct contradiction. Listing an NFT is a mutation, so the tool is not read-only. This inconsistency severely harms transparency.

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 contains extra context like 'SAP MCP context: Protocol 3land; operation class write' which is redundant. The sentence about 'pair marketplace actions...' is unclear and could be omitted. It is not optimally concise.

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 description is incomplete due to the annotation contradiction. It does not explain return values or behavior when listing fails. The tool is a write operation, but the annotations misrepresent its nature, leading to confusion.

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 meaningful semantics beyond the schema; it merely lists parameters like 'mint' and 'price' without additional context.

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?

Description clearly states the action: 'List an NFT for sale on 3.Land in any SPL token.' The verb 'list' and resource 'NFT for sale' are explicit. It distinguishes from sibling tools like '3land_buyNFT' and '3land_cancelListing' by mentioning the listing flow.

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 advises to 'Confirm marketplace price, seller/buyer wallet, collection, and listing state before writes' which provides some guidance but lacks explicit when-not-to-use or alternatives. The mention of 'pair marketplace actions with SAP registry metadata' is vague and not actionable.

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 write operation (readOnlyHint=false). The description adds context about SAP MCP, operation class write, and pairing with SAP registry metadata, which provides extra behavioral context. However, it does not disclose failure modes, atomicity, or what happens if listing fails after mint, leaving gaps in transparency 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 concise, covering purpose, context, and a warning in a few sentences. It is front-loaded with the main action. However, some phrasing ('SAP MCP context') is technically dense and may not be immediately clear, slightly reducing 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?

With a complex operation (mint + list), 9 parameters (100% coverage but weak descriptions), and existing output schema, the description provides minimal completeness. It lacks parameter explanations, return value details, and error scenarios. It is adequate for a basic understanding but insufficient for confident invocation without further 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%, but many parameter descriptions are generic (e.g., 'Name name or domain value used by 3land Mint And List.'). The description does not clarify parameter meaning or relationships beyond what the schema provides, adding little value. Baseline 3 is reduced due to poor schema descriptions not compensated by the main description.

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 mints an NFT and lists it for sale, which is a specific verb-resource combination. It distinguishes from siblings like 3land_createCollection, 3land_listForSale, and 3land_buyNFT by combining both actions, making the purpose unique and clear.

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 broad usage context ('Use for 3.Land NFT collection, minting, listing, cancellation, and purchase flows') and a warning to confirm state before writes, but it does not explicitly differentiate when to use this tool versus alternatives like 3land_listForSale or 3land_createCollection. Lacks explicit when/why-not 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=false, idempotentHint=false, destructiveHint=false. The description adds no additional behavioral context beyond 'Add collateral,' such as prerequisites, side effects, or error conditions.

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

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

The first sentence is concise and clear. The second sentence about SAP registration is somewhat extraneous for describing this tool's purpose, but it doesn't significantly detract from readability.

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 description explains the basic operation but lacks details on prerequisites, success/failure conditions, or wallet ownership requirements. With an output schema present, return values are covered, but more context would be helpful for a financial 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 clear descriptions for amount, wallet, and positionKey. The tool description does not add any extra meaning beyond what the schema already provides.

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 'Add collateral to an existing Adrena position,' which is a specific verb+resource. Among sibling tools like adrena_openPosition, adrena_closePosition, adrena_removeCollateral, this clearly distinguishes its unique action.

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 does not provide guidance on when to use this tool versus alternatives (e.g., adrena_removeCollateral). The note about SAP registration is tangential and does not address usage context.

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 destructiveHint=true and readOnlyHint=false. The description confirms the destructive nature ('close') but adds no further behavioral context such as fee implications, collateral return, or permission requirements.

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 first sentence is concise and focused. The second sentence introduces unrelated SAP context, which dilutes clarity and does not help in selecting this 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?

Despite having an output schema (not shown), the description lacks important context such as prerequisites (e.g., must have an existing position), side effects, and the outcome of closing (e.g., returns of collateral). For a destructive tool, more completeness is needed.

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, so the schema alone documents both parameters as 'Solana public key (base58)'. The description adds no additional meaning or usage hints for the 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 clearly states the action ('Close') and the resource ('perpetual position on Adrena Protocol'). It distinguishes from sibling tools like adrena_openPosition and adrena_addCollateral by specifying closing rather than opening or modifying positions.

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 includes SAP context about registering agents, but provides no guidance on when to use this tool versus other Adrena tools (e.g., when you have an open position). No prerequisites 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 readOnly=true, idempotent=true, destructive=false. Description adds no additional behavioral context beyond stating it gets open positions. No contradiction.

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

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

Two sentences: first conveys purpose, second adds contextual SAP guidance. Could be slightly more concise by removing the second sentence if not needed, but not overly verbose.

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?

Adequate for a simple read-only tool with one parameter and output schema. Annotations fill safety/idempotency. No missing info about auth or return format (output schema exists).

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 covers the single parameter (wallet) with 'Solana public key (base58)'. Description text does not add further parameter meaning. Baseline 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?

Clearly states 'Get all open positions on Adrena Protocol.' Distinct from sibling adrena tools (addCollateral, closePosition, etc.) and includes protocol name.

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?

Implies usage for reading positions, but does not explicitly state when to use this tool vs. other similar tools like drift_getPositions. The SAP context sentence instructs when to use other tools, not 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 indicate mutation (readOnlyHint=false) and non-destructive (destructiveHint=false), but the description does not add details about side effects, such as collateral locking, price impact, or liquidation risks. The behavioral transparency beyond annotations is minimal.

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 short but includes an irrelevant second sentence about SAP tool registration that does not belong. It is not optimally concise; the extraneous content reduces effectiveness.

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 tool with 8 parameters, required fields, and a mutation operation, the description lacks essential context about prerequisites (e.g., wallet connection), post-operation effects, or relationship to other adrena tools. An output schema exists but the description does not reference expected outcomes.

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, so the schema itself describes each parameter adequately. The description does not add extra meaning or context for parameters beyond what is in the schema. 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 action ('Open a leveraged perpetual position') and the protocol ('Adrena Protocol'). However, the inclusion of SAP MCP context about registering tools adds confusion and does not directly clarify the tool's purpose, slightly diluting 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 does not provide guidance on when to use this tool versus alternative tools like adrena_closePosition or adrena_getPositions. The SAP context is about registration, not usage scenarios. No explicit when-to-use or when-not-to-use information.

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 destructiveHint=true and readOnlyHint=false, indicating a destructive operation. The description adds no further behavioral context beyond stating the action.

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 concise with two sentences. The second sentence about SAP context is potentially useful but slightly extraneous for core functionality.

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 description covers the basic action but lacks context on prerequisites, reversibility, or post-conditions. The presence of an output schema mitigates the need for return value details.

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 descriptions for each parameter. The tool description does not add additional meaning beyond what the schema provides.

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 'Remove collateral from an Adrena position,' using a specific verb and resource. It distinguishes from sibling tools like adrena_addCollateral and adrena_closePosition.

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 does not provide guidance on when to use this tool versus alternatives. The mention of SAP tools is tangential and not about this tool's usage context.

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 idempotentHint=true, covering safety and idempotency. The description reinforces this with 'Protocol alldomains; operation class read' and notes it as 'discovery context', which implies no side effects. Given the rich annotations, the description adds useful context without being essential.

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 and front-loaded with the core purpose. The first sentence is direct, and the second adds usage context. The 'SAP MCP context' line is redundant with annotations but not overly verbose. 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?

The tool is a simple read operation with an output schema, so the description does not need to explain return values. It covers the essential 'what' and 'when', though it omits details like pagination or data freshness. For a list discovery tool, this is adequate and complete enough for proper invocation.

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?

Input schema coverage is 100% with clear descriptions for both parameters (wallet: 'Solana public key (base58)', tld: 'Filter by TLD'). The description adds 'across all TLDs' to hint that omitting tld returns all TLDs, but does not provide additional detail beyond the schema. 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 'Get all domains owned by a wallet across all TLDs', specifying the verb 'get' and the resource 'domains owned by a wallet'. It distinguishes from sibling tools like alldomains_registerDomain (create) and alldomains_resolveDomain (resolve specific domain), making its unique purpose clear.

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 says 'Use to list domains owned by a wallet through AllDomains' and advises 'Use as discovery context before choosing a name to associate with an agent'. This provides clear when-to-use guidance, though it does not explicitly mention when not to use or alternatives beyond the sibling tools' implied separation.

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 are present and the description adds operational context ('operation class write') and a caution about pre-write confirmation. However, it does not detail side effects, costs, or ownership changes beyond registration.

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 concise with two main sentences and a context line. It is front-loaded with purpose, though the 'SAP MCP context' line is somewhat technical and can be trimmed.

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?

Covers the core purpose, usage caveats, and parameter context. However, it lacks information on prerequisites (e.g., wallet funding), success conditions, and potential errors. The output schema is present, so return values are not needed in the description.

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%. The description adds context for the tld parameter by listing supported TLDs and provides general guidance for parameter usage. This adds meaningful 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 clearly states the verb 'register' and resource 'domain' with supported TLDs. It distinguishes from sibling tools like sns_resolveDomain by specifying 'use only when not SNS-specific', but mixes registration and resolution workflows slightly.

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?

Explicitly states when to use ('use only when the requested name service is not SNS-specific') and advises caution ('Confirm domain, TLD, owner, and renewal or purchase terms before writes'). No explicit mention of alternatives, but the context is clear.

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 provide readOnlyHint and idempotentHint. Description adds that it resolves to owner wallet and does not change ownership or records, reinforcing the safe read behavior. Includes operation class 'read' context. No contradictions.

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, each serving a distinct purpose: first sentence defines the action, second provides context and usage guidance. No wasted words, front-loaded with key 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?

Given the tool's simplicity (1 param, read-only, output schema present), the description covers purpose, usage constraints, and behavioral guarantees. It adequately distinguishes from sibling tools and completes the picture for an agent.

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% and baseline is 3. Description adds 'multi-TLD domain' clarification to the parameter 'domain', enhancing meaning beyond the schema's 'Full domain to resolve'.

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?

Clearly states verb 'Resolve' and resource 'multi-TLD domain to its owner wallet'. Distinguishes from SNS-specific tools by specifying 'Use only when the requested name service is not SNS-specific.'

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?

Explicitly states when to use: 'Resolve an AllDomains name without changing ownership or records', and when not to use: 'Use only when the requested name service is not SNS-specific.' Provides clear context with alternatives implied (SNS 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?

Description mentions 'operation class read' while annotations set readOnlyHint=false, creating a contradiction. Beyond that, no disclosures about side effects, authentication, or rate limits. The tool builds URLs which is typically non-destructive, but the inconsistency with annotations reduces transparency.

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?

Description is somewhat verbose with repetitive context like 'SAP MCP context: Protocol blinks; operation class read'. Could be more concise by removing redundant phrases. Still, it is not excessive.

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 presence of an output schema, the description adequately covers the tool's purpose, parameters, and usage context. Minor gap: does not explain what 'validate actions' entails, but overall complete enough for a URL builder.

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?

Input schema has 100% description coverage, so the baseline is 3. The description adds minimal value over schema (e.g., 'optionally wrap' for blinkProvider). No additional syntax or format details are provided.

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?

Description clearly states it builds a Solana Action URL, optionally wraps it as a Blink. It distinguishes from sibling tools like blinks_getAction, blinks_confirmAction, blinks_executeAction by mentioning metadata fetch, validation, and POST action preparation. However, the phrase 'operation class read' contradicts the non-read-only annotation.

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?

Description implies usage for constructing action URLs before executing or confirming, but does not explicitly state when not to use it or name alternatives. Sibling tools are listed but not referenced.

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 'operation class read,' which contradicts the annotation readOnlyHint=false, indicating the tool performs a write operation. It also mentions 'Preview and validate actions before signing,' which is misleading because this tool is for confirming after signing. No details are provided about the POST request or side effects 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 somewhat verbose, including extraneous terms like 'SAP MCP context' and 'operation class read.' While it conveys the main idea, it could be more concise and better structured, with the key action stated upfront and unnecessary details removed.

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 output schema exists, the description does not need to explain return values. However, it lacks clarity on the workflow step (after signing) and does not fully compensate for the contradiction between the description and annotations. It is adequate but incomplete.

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% coverage with descriptions for both parameters (actionUrl, signature). The tool description adds nothing beyond the schema, so it meets the baseline. There is no additional explanation of the parameters' semantics or expected formats.

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 that the tool confirms a completed Solana Action by sending the transaction signature back to the Action provider. It distinguishes its purpose from sibling tools like blinks_executeAction and blinks_getAction by focusing on the confirmation step. However, it includes vague phrases like 'metadata fetch, validation, and POST action preparation' that dilute the specific 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?

The description provides some context about using the tool for Solana Actions and Blinks workflows, but it does not explicitly state when to use this tool versus alternatives like blinks_executeAction or blinks_validateActionsJson. There is no guidance on prerequisites (e.g., having a signed transaction) or when not to use 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 indicate destructiveHint=true and readOnlyHint=false. The description adds context about the flow—sending wallet to endpoint, receiving transaction to sign—and cautions about confirming intent before invocation. This aligns with annotations and provides helpful safety context beyond what annotations alone 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?

The description is brief and focused, with key information front-loaded. Every sentence adds value without redundancy. It includes protocol context and operational guidance in a compact format.

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 (write operation with transaction signing), the description covers essential behavioral and safety aspects. The presence of an output schema reduces the need to detail return values. However, it could briefly mention that the transaction needs to be submitted after signing.

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?

Input schema coverage is 100% with descriptions for all three parameters. The description does not add significant new meaning beyond the schema, though it mentions 'actionUrl' comes from getAction links, which is minor added context. 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 executes a Solana Action by sending a wallet to an endpoint and receiving a transaction to sign. It specifies the protocol (Blinks) and operation class (write), distinguishing it from sibling tools like blinks_getAction or blinks_confirmAction.

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 guidance to confirm metadata, parameters, expected transaction, and user intent before invoking, and advises previewing and validating output before signing. It mentions using SAP transaction tools for submission, but does not explicitly state when not to use the tool or list alternative 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?

Annotations already declare readOnlyHint, destructiveHint, and idempotentHint. The description adds context about preview/validation, but does not contradict annotations or provide new behavioral details.

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

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

Three sentences, front-loaded with purpose and output, each sentence serves a distinct role. No redundancy or 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?

Given the simple tool with 1 param, complete annotations, and output schema present, the description adequately covers what to expect and when to use it. No gaps.

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 baseline is 3. The description does not add extra meaning to the actionUrl parameter beyond what the schema provides.

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 metadata for a Solana Action (Blink), listing specific return fields. It distinguishes from sibling tools like blinks_executeAction and blinks_confirmAction.

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 advises using the tool for metadata fetch, validation, and POST action preparation before signing. It implies a step in a workflow but does not explicitly name alternatives or exclusion conditions.

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 declare readOnlyHint=true, destructiveHint=false, so safety is clear. The description adds workflow context (preview before signing) but no new behavioral traits 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?

Three sentences, front-loaded with the action, then context. No unnecessary words; every sentence 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?

Given the simple tool with rich annotations and output schema, the description covers purpose, usage, and workflow integration. Lacks details on error cases but 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 coverage is 100% with parameter description included. The description reinforces the parameter's purpose but doesn't add new semantics 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 it resolves a Blink URL to an underlying Solana Action URL, with examples and use cases. It distinguishes from siblings by specifying 'underlying Solana Action URL' and SAP context.

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 when-to-use guidance: for metadata fetch, validation, and POST action preparation, and as a preview before signing. It lacks explicit when-not-to-use but implies its read-only nature.

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 show readOnlyHint=false, which suggests possible writes, but the description implies a read-only check ('checks if a website correctly implements'). The description does not clarify if the tool makes network requests or modifies state, which is a gap in transparency given the annotation. No contradiction, but more detail would help.

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 concise, consisting of two sentences and a brief note on SAP MCP context. It is front-loaded with the main purpose, but the structure could be improved for readability (e.g., bullet points). No wasted words.

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 parameter, output schema exists), the description sufficiently explains what it does and when to use it. It covers the domain validation purpose and its place in the transaction preparation workflow. Completeness is adequate for this 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?

Schema coverage is 100% with a well-described parameter 'domain'. The description adds no extra meaning beyond the schema's definition, 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 validates a domain's actions.json file against the Solana Actions spec, which distinguishes it from sibling tools that handle other aspects (build URL, confirm, execute, etc.). The verb 'Validate' and the resource 'domain's actions.json file' are specific and 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 indicates the tool is used for validation and preview before signing or submitting transactions, providing context on when to use it. It does not explicitly state when not to use it or list alternatives, but the sibling tools imply the workflow, so it's clear enough.

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 destructiveHint=true; description adds note about confirming fees and finality, but no further behavioral details like potential delays or reversibility.

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?

Description is somewhat verbose, includes SAP MCP context that may not be relevant for general agent use. Could be more concise.

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 8 parameters and output schema, description covers basic usage but lacks details on return values, error handling, or finality guarantees. Adequate but not comprehensive.

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 baseline 3 is appropriate. Description reiterates some parameters but adds no new semantic 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?

Clearly states the tool bridges tokens across chains using deBridge DLN. Slightly confusing by also mentioning Wormhole in usage, but overall specific verb and resource.

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 context on when to use (cross-chain asset movement) and mentions calling status tool after submission. However, does not explicitly differentiate from sibling bridging_bridgeWormhole or state when not to use.

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 'operation class read', indicating a non-destructive read operation. However, annotations set destructiveHint=true and readOnlyHint=false, contradicting the description. The description adds useful behavioral context (read, audit trail) but the contradiction undermines trust.

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 concise with three sentences: purpose, context, usage. It is well-structured and front-loaded, with no redundant content, though could be slightly more terse.

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 (one parameter, read operation), the description is relatively complete. It explains the workflow (after bridge submission), output context (audit trail), and benefits from the presence of an output schema (not shown but present). Minor gap: no explanation of output format beyond 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 coverage is 100%, so the parameter is already fully documented. The description does not add additional semantics beyond the schema, providing no extra value for parameter understanding.

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 checks the status of a deBridge DLN cross-chain transfer, using a specific verb (Check) and resource (status of transfer). It distinguishes from siblings like bridging_bridgeWormholeStatus by naming the protocol (deBridge) and specifying the DLN order ID.

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 says to call this after bridging_bridgeDeBridge and to keep the result with the user-facing audit trail. It provides clear sequential context but does not explicitly mention when not to use it or list alternatives, though sibling tools provide implicit differentiation.

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 indicate destructiveHint=true, and description adds that it is a write operation ('operation class write') and mentions checking fees and finality expectations, providing behavioral 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?

Description is clear and front-loaded with core purpose. Includes SAP context which may be necessary but adds length. Overall well-structured but slightly verbose.

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 output schema exists, the description covers usage, prerequisites, post-submission steps (calling status tool), and SAP agent integration. Fully adequate for a bridge write 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 has 100% coverage, so parameters are well-documented. Description adds value by emphasizing confirmation of source chain, destination chain, token mint, amount, recipient, route fees, and finality expectations, but does not add new semantic details 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?

Clearly states it bridges tokens across chains via Wormhole, supports Solana ↔ EVM chains. Distinguishes from sibling tools like bridging_bridgeDeBridge and bridging_bridgeWormholeStatus by naming the protocol.

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?

Explicitly says to use for cross-chain asset movement through Wormhole, provides prerequisites (confirm source/destination chains, token, amount, etc.), and advises to call status tool after submission. Also mentions SAP agent registration where applicable.

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?

There is a clear contradiction between the description and annotations. The description states 'operation class read', but annotations have readOnlyHint=false and destructiveHint=true, implying the tool may be destructive and not read-only. The description does not explain any destructive behavior or resolve this inconsistency, making it misleading.

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 concise: two sentences plus a brief SAP context note. It front-loads the purpose and usage guidance. Every sentence adds value, with no wasted words.

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?

Although an output schema exists, the description fails to address the destructive hint from annotations and does not explain whether the status check has any side effects or requires special permissions. The contradiction undermines completeness. The description is inadequate for a tool with contradictory metadata.

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 schema already describes both parameters ('sequence' and 'sourceChain') adequately. The description adds no additional meaning or context beyond what the schema provides. 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's purpose: 'Check the status of a Wormhole bridge transfer.' It distinguishes from its sibling bridging_bridgeWormhole by specifying that it is used after a bridge submission. The verb 'check' and resource 'status of a Wormhole bridge transfer' are specific and clear.

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: 'Call this after bridging_bridgeWormhole and keep the resulting status with the user-facing bridge audit trail.' It tells when to use the tool (after bridge submission) and what to do with the result. No explicit exclusions or alternatives are mentioned, but the context is clear and 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 readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds that data is 'advisory context' and 'On-chain SAP settlement and escrow state remain authoritative for payments', which provides useful behavioral nuance beyond annotations. No contradictions.

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 contains five sentences, some redundant (e.g., 'Use market data as advisory context' is partly repeated). The first sentence is clear, but subsequent sentences could be merged or removed for 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?

With an output schema present and comprehensive annotations, the description covers the core purpose and advisory nature. However, it does not explain the meaning of OHLCV or the days parameter options beyond the schema. Adequate but not thorough.

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 all parameters described, but the descriptions are tautological (e.g., 'Days parameter for Coingecko Get O H L C V'). The tool description adds no extra meaning about parameters. Baseline score of 3 is appropriate as parameters are documented but not enriched.

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 OHLCV (price chart) data from CoinGecko', specifying the verb (get) and resource (OHLCV data). It distinguishes from sibling coingecko tools (e.g., getTokenPrice, getPoolsByToken) by focusing on price chart 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 provides context for using this tool: 'Use for off-chain market data such as token prices, trending assets, token info, pools, and OHLCV' and notes that on-chain SAP state is authoritative. However, it lumps multiple data types into a single sentence, which could cause confusion since the tool is specifically for OHLCV. Still, it gives clear advisory context.

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 idempotentHint=true, so the safety profile is clear. The description adds that data is from 'CoinGecko on-chain DEX tracker' and is 'off-chain market data', which is helpful context but does not disclose behavioral traits like pagination or rate limits. No contradiction with annotations.

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

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

The description is two sentences and a brief metadata line ('SAP MCP context:...'), which is relatively concise. The metadata line might be extraneous for agent selection, but overall structure is clear and front-loaded with the core purpose.

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

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

An output schema exists (not shown but assumed complete), so return values don't need elaboration. The description provides sufficient context about data source and advisory nature. Could mention limitations (e.g., only covers tracked DEXs), but overall adequate for a read-only pool 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?

Input schema coverage is 100% with parameter descriptions for all three fields (tokenAddress, page, network). The description adds no parameter-specific info beyond what the schema already provides, 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 explicitly states 'Get all liquidity pools for a token from CoinGecko on-chain DEX tracker', clearly identifying the verb ('Get'), resource ('liquidity pools for a token'), and data source. It distinguishes from sibling coingecko tools that focus on prices, trends, or OHLCV.

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 context: 'Use for off-chain market data such as token prices, trending assets, token info, pools, and OHLCV' and contrasts with on-chain SAP data. It implicitly guides when to use this pool-specific tool vs other coingecko tools, but lacks explicit exclusionary guidance (e.g., 'For token prices, use getTokenPrice instead').

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 declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false. The description adds 'operation class read' and specifies return type (description, links, market data) and advisory nature. No contradictions; adds useful 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 concise: a few sentences with front-loaded purpose. Each sentence adds value: purpose, operation class, use cases, advisory role. No wasted words.

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 an output schema, 1 parameter, and no nested objects, the description sufficiently explains what data is returned and its advisory role. It covers the key behavioral 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 one parameter (tokenId, described as 'CoinGecko token ID'). The description does not elaborate on tokenId format or source, so it adds no additional semantics 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 'Get detailed token information from CoinGecko (description, links, market data)'. It names specific data types and distinguishes from sibling tools like coingecko_getTokenPrice and coingecko_getTrending.

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 context: 'Protocol coingecko; operation class read' and lists use cases: 'off-chain market data such as token prices, trending assets, token info, pools, and OHLCV'. It also advises 'Use market data as advisory context. On-chain SAP settlement and escrow state remain authoritative for payments,' guiding when to use versus not. It doesn't directly name alternatives but implies distinction.

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, idempotentHint, and non-destructive. The description adds value by clarifying that data is off-chain and advisory, which is important for trustworthiness. No contradictions with annotations.

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

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

The description is two sentences plus a context note, all front-loaded. Every sentence is informative with no fluff. Efficiently communicates purpose and usage.

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 description covers purpose, usage context, and behavioral notes. With an output schema present, it need not detail return fields. Lacks mention of data freshness or real-time nature, but overall adequate for a read-only 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 coverage is 100%, so baseline is 3. The description does not add any parameter-specific meaning beyond what the schema already provides. It only mentions general market data categories.

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 token price and market data from CoinGecko', specifying the source and broad scope. It lists examples (token prices, trending assets, token info, pools, OHLCV) that distinguish it from siblings like coingecko_getOHLCV and coingecko_getTokenInfo.

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 advises using this tool for off-chain market data and emphasizes that on-chain SAP data is authoritative for payments, providing clear usage context. However, it does not explicitly contrast with sibling tools or state when not to use 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, openWorldHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable context: it confirms the operation class as 'read', labels the data as off-chain and advisory, and clarifies that on-chain SAP settlement remains authoritative for payments. This goes beyond the annotations to warn the agent about data provenance.

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 efficient: it opens with the core purpose in one sentence, then adds contextual sentences about protocol, operation class, and usage guidance. It is not overly verbose and front-loads the primary action. Could be slightly more concise by omitting the redundant mention of 'token prices, trending assets...' but still effective.

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 low complexity (2 parameters, no required, output schema present), the description covers the essential points: what it retrieves, its off-chain nature, and advisory role. The warning that on-chain state is authoritative for payments is a helpful contextual detail. The output schema supplies return format information, so the description does not need to elaborate further.

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%, and the descriptions are minimal but present. The tool description does not add any additional meaning about the parameters (e.g., expected format for vsCurrency or typical duration values). Since coverage is high, a baseline of 3 is appropriate; no extra value is added.

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 verb 'get' and resource 'top gainers and losers from CoinGecko'. It also provides context about the protocol and operation class, distinguishing it from other sibling tools like coingecko_getTrending or coingecko_getTokenPrice.

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 only broadly groups this tool with other off-chain market data tools ('Use for off-chain market data such as token prices, trending assets, token info, pools, and OHLCV'), but does not provide explicit guidance on when to choose this specific tool over alternatives like coingecko_getTrending or coingecko_getTokenInfo. No when-not-to-use or alternative differentiation is given.

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, idempotentHint=true, destructiveHint=false. Description adds that it returns trending tokens and NFTs, which is expected and does not reveal new behavioral traits.

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

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

Four sentences that are clear and front-loaded. Could be slightly more concise but effectively communicates purpose.

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 an output schema and no parameters, the description sufficiently explains the tool's functionality and advisory nature, though it could mention returning JSON or pagination if applicable.

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?

No parameters; schema coverage is 100%. Description adds nothing about parameters but is not required.

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 gets trending tokens and NFTs on CoinGecko, and among sibling CoinGecko tools it is distinct as the only one for trending 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?

Describes use for off-chain market data and clarifies that on-chain data is authoritative. Does not explicitly exclude use cases but implies advisory context.

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 claims the tool is for 'asset discovery by owner, creator, collection, or search query', which contradicts the fact that it only accepts an id parameter. This is misleading about the actual behavior. Annotations already indicate readOnlyHint, destructiveHint false, etc., but the description adds inaccurate context.

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 short with three sentences, but one sentence ('SAP MCP context: Protocol das; operation class read.') adds little value for the agent. The first sentence is clear, but the second sentence is misleading. Conciseness is acceptable but not optimal.

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 only one parameter and an output schema exists, the description should be sufficient, but it is incomplete due to inaccurate claims about discovery capabilities. It does not mention error handling or what happens when an asset is not found, leaving gaps for the agent.

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 sole parameter id having a clear description 'Asset mint address'. The description does not add any additional 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 'Get detailed information about a single NFT/asset via DAS', using a specific verb and resource. It distinguishes from sibling tools like das_getAssetsByOwner or das_searchAssets by emphasizing 'single asset', which aligns with the id parameter.

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 useful context: 'Use for read-only DAS NFT and asset discovery' and advises to 'Prefer DAS reads before Metaplex writes when validating existing assets.' However, it does not explicitly exclude cases where alternative tools should be used or mention 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?

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true. The description adds 'read-only' and 'operation class read,' which are consistent but do not reveal new behavioral traits beyond 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 relatively short but includes an overgeneralized sentence about 'owner, creator, collection, or search query' that may mislead. It could be tighter and more focused on the collection scope.

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 an output schema and full schema descriptions, the description covers the basic operation but lacks mention of pagination (page/limit) and does not fully differentiate this tool from its DAS siblings. Adequate but with gaps.

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 already described in the schema. The description does not add extra meaning or constraints for any parameter; 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 opening sentence 'Get all NFTs in a collection via DAS' clearly states the verb and resource. However, the later sentence about 'owner, creator, collection, or search query' blurs the distinction from sibling tools like das_getAssetsByOwner and das_searchAssets, reducing differentiation within the DAS family.

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 advises 'Prefer DAS reads before Metaplex writes when validating existing assets,' which provides cross-category guidance but does not specify when to choose this tool over other DAS read tools (e.g., das_getAssetsByOwner). No explicit exclusions or alternatives are given.

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, idempotentHint=true, destructiveHint=false. The description adds 'Protocol das; operation class read' which reinforces annotations but offers no additional behavioral context beyond what annotations already 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 three sentences, front-loading the main purpose, then adding protocol context and usage guidance. No redundant or extraneous 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 presence of an output schema and comprehensive annotations, the description is fairly complete. However, it does not explicitly differentiate from sibling tools like das_getAssetsByOwner or das_getAssetsByCollection, which could help in selection.

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 each parameter having a description (though auto-generated). The tool description does not add any parameter-specific information beyond the schema, so it meets the baseline but does not exceed it.

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 all NFTs/assets created by a specific creator via DAS', specifying the verb 'Get' and the resource 'NFTs/assets by creator'. It distinguishes from siblings by focusing on creator-based queries.

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 usage context: 'Use for read-only DAS NFT and asset discovery... Prefer DAS reads before Metaplex writes'. However, it does not explicitly exclude alternative tools like das_getAssetsByOwner or provide when-not-to-use 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, idempotentHint, and destructiveHint=false. The description reinforces read-only behavior and pagination support but adds little 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?

Description is three sentences, efficient and front-loaded. Each sentence adds value: purpose, context, and usage guidance. No unnecessary words.

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 output schema and annotations, the description is mostly adequate. However, it suggests broader filtering capabilities (by creator, collection, etc.) that the input schema does not support, potentially misleading agents.

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 baseline is 3. The description mentions pagination but does not explain parameters like page, after, limit, before, or sortBy beyond what the schema provides.

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?

Description clearly states the tool retrieves NFTs/assets by owner with pagination. However, it also implies it can be used for discovery by creator, collection, or search query, which is not reflected in the input schema and may cause confusion with sibling tools like das_getAssetsByCreator.

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?

Description advises to prefer DAS reads before Metaplex writes, giving context for when to use it. But it does not differentiate among DAS read tools (e.g., das_getAssetsByCreator) or clearly 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?

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, destructiveHint=false. The description adds minimal behavioral context, just stating 'operation class read.' It does not disclose pagination details, result limits, or potential side effects beyond what annotations cover. No contradictions.

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 relatively concise at 4 sentences, front-loading the core action. The third sentence adds context ('SAP MCP context: Protocol das; operation class read') and the last provides usage guidance. It could be slightly tighter, but overall well-structured 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?

Given the tool has 9 optional parameters and no required fields, the description omits guidance on parameter combinations or defaults. While output schema exists, return values are not addressed. The description covers high-level usage but lacks completeness for complex filtering scenarios.

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?

Input schema has 100% description coverage, but descriptions are generic (e.g., 'Burnt parameter for Das Search Assets'). The tool's description does not add meaningful semantics to individual parameters, only listing use cases (owner, creator, etc.). Baseline 3 is appropriate as schema covers parameter existence, but not enrichment.

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 NFTs/assets with flexible filters via DAS.' It specifies the resource (NFTs/assets) and action (search), and distinguishes from sibling tools like das_getAsset by mentioning 'flexible filters' and listing discovery criteria (owner, creator, collection, search query).

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 guidance: 'Use for read-only DAS NFT and asset discovery by owner, creator, collection, or search query.' It also advises preference: 'Prefer DAS reads before Metaplex writes when validating existing assets for an agent profile, collection, or metadata update.' While it doesn't explicitly list when not to use it, the context and alternative are implied.

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=false, so the description's 'Borrow' aligns with a write operation. However, it adds no further behavioral detail (e.g., effect on collateral, fees, or debt). The bar is lower due to annotations, but the description minimally augments transparency.

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 concise with two sentences. The first sentence is front-loaded with the core purpose. The second sentence about SAP MCP context is slightly tangential but does not detract significantly. Every sentence serves a purpose, though the second could be omitted for brevity.

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 (financial borrowing on Drift) and the presence of an output schema, the description covers the basic purpose and prerequisite. However, it lacks details on what happens after borrowing (e.g., impact on borrowing power, liquidation risk). It is adequate but not fully comprehensive.

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%, providing clear descriptions for all four parameters. The description does not add extra meaning beyond the schema's parameter definitions, meeting the baseline for a well-documented 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 'Borrow tokens on Drift against deposited collateral,' which specifies the verb (borrow), resource (tokens on Drift), and the prerequisite (deposited collateral). It distinguishes from sibling tools like drift_deposit and drift_lend, but does not explicitly contrast them.

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

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

The description implies usage context by mentioning 'against deposited collateral,' indicating a prerequisite. However, it lacks explicit 'when to use' or alternative recommendations, such as comparing with drift_lend or drift_openPerpPosition. The SAP MCP context is tangential to tool usage.

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 destructiveHint=true and readOnlyHint=false, so the description's assertion of 'close' aligns. However, no additional behavioral details (e.g., signature requirements, settlement behavior) are disclosed beyond what annotations imply.

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 first sentence is concise, but the SAP MCP context paragraph is irrelevant to the tool's core function and adds unnecessary length. The description could be more focused.

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 having an output schema, the description does not specify return values or side effects (e.g., transaction broadcast, balance changes). For a destructive action, details like confirmation and error handling are missing.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters. The description adds no extra meaning beyond what's in the schema, merely repeating 'Market Index parameter' for marketIndex.

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 'Close a perpetual position on Drift', using a specific verb (close) and resource (perp position). It distinguishes from sibling tools like drift_openPerpPosition and drift_getPositions.

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 includes a tangent about SAP MCP context discussing sap_register_agent etc., but does not provide guidance on when to use this tool vs alternatives like drift_closePosition (adrena) or other protocols. No explicit when-to-use or when-not-to-use instructions.

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 this is a write operation (readOnlyHint=false). The description adds the purpose (trading/lending) but does not disclose other behavioral traits like fees or confirmation requirements. It adequately complements 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 concise with two sentences. The first sentence clearly states the tool's purpose. The second sentence provides SAP context, which is somewhat tangential but not excessively verbose.

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 description explains the core purpose but omits details like prerequisites (e.g., needing a Drift account) and the role of the optional subAccountId. With a output schema present, it is minimally adequate but not fully comprehensive.

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% coverage with clear descriptions for all four parameters. The tool description adds no additional parameter-level information beyond what the schema already provides, 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 verb 'deposit' and resource 'tokens into a Drift account' with the purpose 'for trading or lending'. It distinguishes from sibling tools like drift_withdraw, drift_lend, and drift_borrow.

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 does not explicitly state when to use this tool versus alternatives. The SAP context provided is about other tools, not about deposition alternatives. There is no guidance on preconditions or exclusion criteria.

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, idempotentHint, and destructiveHint. Description adds no extra behavioral traits, but is consistent with annotations.

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

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

Efficient two-sentence description. The SAP context adds moderate value but is somewhat tangential.

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 read-only intent, output schema, and clear parameter schema, the description is nearly complete. Could mention wallet requirement explicitly.

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 descriptions; the description adds no further meaning to the 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?

Clearly states 'Get all open positions and account info for a Drift account,' distinguishing it from sibling tools like drift_openPerpPosition and drift_closePerpPosition.

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 on when to use this tool versus alternatives. The SAP MCP context mentions other tools but not for this specific use case.

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 (readOnlyHint=false, destructiveHint=false, openWorldHint=true) are present, but the description does not expand on behavioral aspects such as state changes, multiple call effects, or prerequisites beyond the schema. It adds no new behavioral context.

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

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

The description is extremely concise with two sentences, the first stating the core purpose and the second providing SAP context. No waste; front-loaded with the primary action.

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 an output schema present, returns are handled. However, the description omits details about the lending process (e.g., requiring a Drift subaccount, interest accrual mechanics, and the role of the subAccountId parameter). It is adequate but not comprehensive for a DeFi lending 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%, so baseline is 3. The description does not explain individual parameters beyond the schema, but the schema already covers them. No additional semantic value is added.

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 action: 'Lend tokens on Drift to earn interest.' It uses a specific verb (lend), resource (tokens on Drift), and purpose (earn interest), distinguishing it from sibling tools like drift_borrow or drift_deposit.

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 includes SAP MCP context but does not provide guidance on when to use drift_lend versus other financial tools like drift_deposit or lulo_deposit. It lacks explicit when-to-use or when-not-to-use criteria for the lending action 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 indicate readOnlyHint=false and destructiveHint=false, implying mutability but not destruction. The description adds no behavioral context beyond annotations—no mention of side effects (e.g., gas fees, collateral requirements, liquidation risk), execution semantics, or error handling. For a financial mutation tool, this is insufficient.

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

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

The description has two distinct parts: a clear one-sentence tool purpose, followed by a lengthy, tangential paragraph about SAP integration context. This extra content is not relevant to opening a perp position and dilutes the description. The useful part is very short but the irrelevant part adds unnecessary 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?

Despite having an output schema (reducing the need to document return values), the description fails to cover prerequisites (e.g., funded Drift account, sufficient balance, subaccount setup) or constraints (e.g., market availability, leverage limits beyond the max 20x). For a complex DeFi trading tool, this leaves critical gaps.

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 9 parameters. The tool description itself adds no parameter information beyond the title, which is acceptable because the schema already provides full semantics. 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 verb 'Open' and the resource 'a perpetual futures position on Drift'. It distinguishes from sibling tools like drift_closePerpPosition by naming a specific action. The resource and action are 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 includes irrelevant SAP MCP context about registering agents, but provides no guidance on when to use this tool instead of other perp opening tools (e.g., adrena_openPosition) or related Drift tools (e.g., drift_deposit, drift_borrow). There is no when-to-use or when-not-to-use advice.

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 destructiveHint=true and readOnlyHint=false, so the mutation nature is clear. The description adds no additional behavioral context, such as side effects, prerequisites, or confirmation steps.

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 first sentence is concise and essential. The second sentence about SAP MCP context is tangential and adds clutter for a Drift tool. It could be shorter or moved elsewhere.

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 description is minimal. While annotations and schema cover many aspects, the description lacks information about the role of subAccountId, any prerequisites, or return value expectations. For a destructive operation, more context would be beneficial.

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 descriptions for all parameters. The tool description adds no extra meaning beyond what the schema provides, so 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 'Withdraw tokens from a Drift account,' using a specific verb and resource. It distinguishes from sibling tools like drift_deposit and drift_borrow through the action of withdrawal.

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. It only mentions SAP context, which is unrelated to Drift operations. The name implies usage but no explicit when-to-use or when-not-to-use.

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 this is a write operation (readOnlyHint=false, destructiveHint=false, idempotentHint=false). The description adds 'with on-chain escrow' but does not elaborate on behavioral details like required wallet signatures, transaction costs, or reversibility. No contradictions with annotations.

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

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

The description is relatively concise but includes filler like 'SAP MCP context: Protocol gibwork; operation class write' which is metadata, not descriptive. The sentence about 'Use for bounty creation, listing, and work submission' is redundant and partially incorrect. Could be tighter.

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?

Output schema exists, so return values are covered. However, the description omits important context about the on-chain nature (e.g., requiring a Solana signature, funds for escrow). For a tool with 7 parameters and 4 required, more procedural context would help.

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 the baseline is 3. The description mentions 'scope, payout, recipient, deliverable evidence' but does not explicitly map these to parameter names or add meaning beyond the schema. No added value.

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 'Create a new bounty on Gib Work with on-chain escrow,' specifying the verb 'create' and the resource 'bounty.' Among siblings (gibwork_listBounties, gibwork_submitWork), it is distinct and 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 says 'Use for bounty creation, listing, and work submission,' conflating purposes that are handled by sibling tools (listBounties, submitWork). It lacks explicit when-to-use or when-not-to-use guidance and does not differentiate from alternatives.

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 declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, clearly indicating a safe read operation. However, the description states 'SAP MCP context: Protocol gibwork; operation class write,' directly contradicting the readOnly hint. This is a serious inconsistency, earning the lowest score per evaluation rules.

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 includes unnecessary sentences like 'SAP MCP context: Protocol gibwork; operation class write' and generic advice that belongs elsewhere. It could be trimmed to just 'List available bounties on Gib Work.' The extra content wastes tokens and does not enhance understanding.

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 an output schema (not shown) reducing the need to describe returns, but the description fails to explain how to use the optional parameters effectively, mention default behavior, or clarify pagination. For a list endpoint, more context on filtering and result structure would be expected.

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 documents all three parameters (tags, limit, status). The description adds no extra meaning or context for the parameters, which is acceptable given full schema coverage, but no value is added beyond the baseline.

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 'List available bounties on Gib Work,' which clearly states the primary purpose. However, it then adds 'Use for bounty creation, listing, and work submission,' which confuses the scope by including creation and submission—tasks belonging to sibling tools. This muddies the purpose and reduces 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 provides no explicit guidance on when to use this tool versus alternatives like gibwork_createBounty or gibwork_submitWork. It includes irrelevant advice about 'Confirm scope, payout, recipient, and deliverable evidence before writes' and 'Use SAP attestation or feedback tools after work completion,' which do not help an agent decide when to call listBounties.

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 destructiveHint: true and readOnlyHint: false. The description adds 'operation class write' and confirmation advice, but does not detail specific side effects or state changes beyond that. No contradiction with annotations.

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

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

The description includes irrelevant SAP context and redundant mentions of bounty creation/listing, making it less concise. It could be trimmed to focus solely on work submission.

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 description mentions confirmation before writes and post-usage SAP tools, but given the destructive nature and existence of an output schema, it could provide more details on expected outcomes or error handling.

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 baseline is 3. The description does not add any parameter-specific information beyond what the schema provides, which already has minimal 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 first sentence clearly states 'Submit completed work for a Gib Work bounty,' but subsequent text says 'Use for bounty creation, listing, and work submission,' which conflates this tool with sibling tools gibwork_createBounty and gibwork_listBounties, reducing 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 advises to 'Confirm scope, payout, recipient, and deliverable evidence before writes,' which provides some prerequisite guidance. However, it does not differentiate when to use this tool versus sibling tools, and it misleadingly includes 'bounty creation, listing' in its scope.

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 idempotentHint=true. The description adds no additional behavioral context beyond 'check the status'. No mention of idempotency, open world, or response format.

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, but the second sentence about SAP MCP context is tangential and does not directly describe the tool. Could be split or removed to improve focus.

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 a simple one-parameter tool and an output schema, the description is minimally adequate but fails to explain the bundle lifecycle or when to use this tool after jito_sendBundle.

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 for bundleId merely restates the schema description. No additional meaning or context about what constitutes a valid bundle ID.

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 checks the status of a submitted Jito bundle, with a specific verb 'check' and resource 'bundle status'. It distinguishes from siblings like jito_sendBundle and jito_getTipEstimate.

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 on when to use this tool versus alternatives. The SAP MCP context is irrelevant to usage of this specific tool. No mention of prerequisites or typical workflow after sending a bundle.

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, idempotentHint=true, and destructiveHint=false. The description adds no behavioral traits beyond these, such as data freshness or rate limits. With annotations covering safety, the bar is met but not exceeded.

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, with the first being front-loaded and directly relevant. The second sentence adds context but slightly dilutes focus. Still concise overall.

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 description explains what the tool does but does not mention output shape, precision of estimates, or any limitations. Given an output schema exists, the missing detail is partially mitigated, but the description could be more 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 tool has no parameters, so the description need not add parameter semantics. Schema coverage is 100% trivially. Baseline of 4 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') and resource ('Jito tip percentile estimates for bundle inclusion priority'). It clearly distinguishes from sibling Jito tools (jito_sendBundle, jito_getBundleStatus) by focusing on tip estimation.

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 (bundle inclusion priority) but lacks explicit guidance on when to use this tool versus alternatives or any prerequisites. The SAP context note is tangential to the tool's core purpose.

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 (readOnlyHint=false, destructiveHint=false) indicate the tool modifies state but is not destructive. The description adds 'MEV-protected' and 'atomic execution' as behavioral traits, but does not elaborate on side effects, failure modes, or the bundle submission process. The description adds moderate value beyond annotations.

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

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

The description is concise (two sentences). The first sentence directly states the purpose. The second sentence adds SAP context, which is relevant but slightly tangential. Overall, it is compact with no superfluous wording.

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 2 parameters with 100% schema coverage, annotations, and an output schema (not shown). However, the description omits constraints like max 5 transactions or tip format, which are in the schema but not reinforced. It also lacks guidance on error behavior or output interpretation, leaving some gaps for an agent.

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 both parameters described. The description does not add any parameter-specific meaning beyond the schema (e.g., no additional format hints for tipLamports or transactions). 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 tool's action: 'Send a Jito bundle for MEV-protected, atomic transaction execution.' It includes a specific verb (Send) and resource (Jito bundle), and distinguishes from sibling tools like jito_getBundleStatus (status) and jito_getTipEstimate (tip estimate).

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 SAP MCP context but lacks explicit guidance on when to use this tool versus alternatives. It mentions related sap_* tools for registration but does not clarify scenarios or prerequisites for sending a bundle, leaving the agent without actionable usage direction.

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 indicate destructiveHint=true, but the description adds that the tool only 'creates an unsigned transaction' rather than executing the cancellation directly. This is important behavioral context not captured by annotations. Also mentions the SAP MCP signer policy, which further clarifies the tool's role in a larger workflow.

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, both essential. The first delivers the core purpose. The second provides critical workflow context. No redundant information. Well 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?

Given the simplicity of the tool (cancel a DCA order), the description is complete. It states what it does, that it produces an unsigned transaction, and how it fits into the broader SAP MCP workflow. An output schema exists, so return values are covered elsewhere.

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?

Input schema has 100% description coverage for all 4 parameters, so the baseline is 3. The description does not add additional meaning beyond what the schema already provides. It mentions the recurring order type implicitly but does not elaborate on parameter values or constraints.

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?

Description clearly states it creates an unsigned transaction to cancel a DCA recurring order. The verb 'cancel' and resource 'DCA recurring order' are specific. Sibling tools like jupiter_createDCA and jupiter_cancelLimitOrder are distinguished by scope (DCA vs limit orders) and action (cancel vs create/execute).

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?

Description provides contextual guidance: states that this tool produces an unsigned transaction and advises using SAP transaction preview/sign/submit tools afterward. This tells the agent the workflow. However, it does not explicitly compare with alternatives like jupiter_cancelLimitOrder or when not to use this tool, so it is slightly incomplete.

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 destructiveHint: true. The description adds the behavioral trait that the tool creates an unsigned transaction (not directly executing), which is key for understanding its role in the signing flow.

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: first clearly states the purpose, second provides essential context about integration with SAP tools. No waste, front-loaded with the core action.

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 description is complete for a single-purpose cancellation tool with an output schema. It explains what it does and how it fits into the broader Jupiter/SAP workflow.

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 clear descriptions for all three parameters. The description does not add additional 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 the verb 'cancel' and the resource 'specific limit order', and distinguishes from sibling tools like jupiter_cancelDCA and jupiter_createLimitOrder.

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 context that this tool prepares an unsigned transaction and should be used with SAP transaction preview/sign/submit tools. Does not explicitly differentiate from jupiter_cancelLimitOrders (plural) but gives sufficient usage guidance for the intended workflow.

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?

Discloses that the tool creates unsigned transactions, which is a key behavioral trait not covered by annotations (destructiveHint=true). Adds context about batch operation and ecosystem integration.

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, no wasted words. Front-loaded with the core purpose, followed by necessary 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?

Given the presence of an output schema (not shown), the description adequately covers the essential behavior (creating unsigned transactions, batch, ecosystem role). Lacks error cases or prerequisites but is sufficient for a tool with good annotations.

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 baseline is 3. Description mentions batch cancellation, which aligns with the orders array parameter, but adds no further parameter-level detail beyond what the schema provides.

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 creates unsigned transactions to cancel multiple limit orders in batch, with a specific verb and resource. It distinguishes from siblings like jupiter_cancelDCA and jupiter_createLimitOrder.

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