SAP MCP Server

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

Annotations already indicate destructiveHint=true and readOnlyHint=false, so the tool is known to be a write with side effects. The description adds valuable context about pricing (paid read-premium), routing constraints (hosted accountless write blocked), and signer boundaries. 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 excessively verbose with SAP-specific context that is repeated in the input schema description. The first sentence is clear, but the rest adds noise and redundancy, reducing conciseness. It could be trimmed to essential guidance.

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 but noted), the description covers the basic operation and some behavioral notes (pricing, routing). However, it lacks a succinct summary of what the tool returns or its prerequisites, relying on the SAP jargon that may not be universally understood. Completeness is adequate but not ideal.

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?

Both parameters (buyer, listingId) are documented in the input schema with descriptions. Schema coverage is 100%, so baseline is 3. The description does not add further meaning to these parameters 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 'Purchase an NFT from a 3.Land listing' as the core purpose. It also mentions its role within broader 3.Land flows, providing context. However, it does not explicitly differentiate from sibling tools like 3land_listForSale or 3land_mintAndList, though the action is distinct enough.

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 confirming marketplace price, seller/buyer wallet, collection, and listing state before writes, which serves as a precondition. It does not explicitly state when to use this tool over alternatives, but the purpose and sibling names make it reasonably clear. The guidance on pricing and routing is present but more SAP-specific than general 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 mark destructiveHint as true and readOnlyHint as false. Description adds 'operation class write' and SAP MCP execution guidance (pricing, routing, signer boundary). This provides behavioral details beyond annotations without 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?

Description front-loads the purpose but is unnecessarily verbose with lengthy SAP MCP execution instructions. Some sentences, especially repetitive routing guidance, could be trimmed without losing utility.

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, description does not need to explain return values. It provides flow context and prerequisites, making it sufficiently complete for an agent. Lacks details on side effects like listing removal, but overall adequate.

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

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

Schema coverage is 100%, so both parameters (seller, listingId) are described in the schema. Tool description does not add new semantic details beyond what is already in the schema, warranting baseline 3.

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

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

Description starts with 'Cancel an active NFT listing on 3.Land.' This clearly states the verb (cancel) and resource (active NFT listing). It distinguishes from sibling tools like 3land_buyNFT and 3land_listForSale, which have different verbs.

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 usage context: 'Use for 3.Land NFT collection, minting, listing, cancellation, and purchase flows.' It also advises to 'Confirm marketplace price, seller/buyer wallet, collection, and listing state before writes.' However, it lacks explicit exclusions or 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 a write operation (readOnlyHint=false), and the description states 'operation class write,' which adds little beyond annotations. It warns about confirming state before writes and pairing with SAP registry metadata, providing some behavioral context. However, it does not disclose side effects like transaction costs, required account balances, or post-creation 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 description is verbose with a lengthy second paragraph of SAP MCP execution guidance (pricing, routing, signer boundary) that is generic and not tool-specific. The first paragraph mixes core purpose with flow guidance, reducing clarity. Key information is front-loaded, but the overall structure is not 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 the complexity (7 parameters, write operation) and presence of an output schema, the description lacks completeness. It does not explain return values, prerequisites (e.g., wallet SOL balance), or error handling. The SAP boilerplate does not compensate for missing operational context.

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

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

Schema description coverage is 100%, so the schema already documents all parameters adequately. The description adds no additional parameter-specific meaning, meeting the baseline score of 3.

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

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

The description begins with a clear verb+resource: 'Create a new NFT collection on 3.Land marketplace.' It distinguishes from sibling tools that handle buying, canceling, listing, and mint+list. However, the phrase 'Use for 3.Land NFT collection, minting, listing, cancellation, and purchase flows' is overly broad and may confuse the tool's exact scope.

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 3land_mintAndList. It mentions 'Confirm marketplace price, seller/buyer wallet, collection, and listing state before writes' as a general safety warning, but does not differentiate context or exclusion criteria from 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?

There is a direct contradiction: annotations declare readOnlyHint=true, while the description labels the operation as 'write' and the tool purpose is to list for sale, which mutates state. The description does not disclose permissions, side effects, or reversal details. With no additional behavioral context beyond the contradiction, transparency is poor.

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

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

The description is excessively long due to repetitive SAP MCP execution guidance that is not tool-specific. The key functional content is compressed into one sentence, while the majority of text is boilerplate. This is not concise and buries the essential 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?

Although an output schema exists, the description fails to provide sufficient context for an agent to use this tool correctly. It lacks guidance on prerequisites (e.g., collection creation, ownership), interaction with sibling tools like 3land_mintAndList, and confirmation steps. The description is incomplete for a complex write operation.

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

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

The input schema provides 100% coverage of parameters with descriptions. The description adds minimal value beyond the schema, only implying token types. It does not explain parameter relationships or constraints like valid ranges for price or expiry format. 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 'List an NFT for sale on 3.Land in any SPL token,' providing a specific verb and resource. However, the purpose is partially obscured by extensive SAP MCP boilerplate text. It distinguishes from siblings like 3land_buyNFT, but the clutter 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 mentions 'Use for 3.Land NFT collection, minting, listing, cancellation, and purchase flows,' offering some context but no explicit when-not or alternatives. It advises confirming state before writes, but lacks clear direction on selecting this tool over others in the sibling list.

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

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

Annotations indicate a write operation (readOnlyHint=false). The description adds substantial behavioral context beyond annotations, detailing the local-signer write workflow, pricing (paid read-premium), routing constraints, and signer boundary. 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 front-loaded with a clear sentence but is followed by a verbose block of SAP MCP execution guidance that repeats similar information (local-signer, pricing, routing). This could be condensed to improve conciseness without losing essential details.

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 core operation, required pre-checks, and execution constraints. However, it does not reference the output schema or explain return values, and the parameter descriptions in the schema are poor. While adequate, there are gaps in completeness.

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

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

Schema description coverage is 100%, so the baseline is 3. The overall description does not add significant meaning beyond the schema; parameter descriptions within the schema are generic (e.g., 'Name name or domain value'). The description implicitly groups parameters but does not enhance understanding of their roles.

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: 'Mint an NFT on 3.Land and automatically list it for sale.' This specific verb+resource combination distinguishes it from siblings like 3land_buyNFT or 3land_cancelListing.

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 (e.g., 'Use for 3.Land NFT collection, minting, listing, cancellation, and purchase flows' and 'Confirm marketplace price...before writes') but lacks explicit guidance on when not to use this tool or clear alternatives. The guidance is implicit rather than directive.

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 confirms 'Add collateral' as a mutation but does not add further behavioral details such as side effects, signing requirements, or whether the operation is atomic. The SAP context implies the need for user signing, but this is not explicit. No contradiction with annotations. With annotations present, the bar is lower, but the description could be more informative.

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 core purpose is stated concisely in the first sentence. However, the subsequent SAP MCP context block is lengthy and repeats content found in the input schema description. While front-loaded, the redundant boilerplate reduces conciseness. Could be trimmed without loss of necessary 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 complexity of a financial tool that modifies on-chain state, the description lacks completeness. It does not specify what the output is (despite an output schema existing), nor does it explain the full transactional flow (e.g., whether a signature is required, how to handle fees). The SAP context hints at payment routing but is not integrated with the tool's behavior. The description is insufficient for an agent to fully understand the consequences of invoking this 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?

The input schema has 100% description coverage with clear descriptions for each parameter: amount ('Raw token amount (smallest unit)'), wallet and positionKey ('Solana public key (base58)'). The tool description adds no additional parameter context beyond what the schema provides. The baseline score of 3 is appropriate given full schema coverage.

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

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

The description begins with a clear and specific statement: 'Add collateral to an existing Adrena position.' This quickly conveys the verb (add), resource (collateral), and context (existing position). It effectively distinguishes from sibling tools like adrena_openPosition (creates new) and adrena_removeCollateral (removes).

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

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

No guidance is provided on when to use this tool versus alternatives. Key usage aspects are missing: prerequisites (e.g., the position must already exist), when not to use (e.g., when you need to remove collateral), or any context of atIONs to consider before invoking. The lengthy SAP MCP context discusses infrastructure but not 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 destructiveHint=true, readOnlyHint=false, idempotentHint=false. The description adds no behavioral details beyond annotations, such as side effects, permission requirements, or return behavior. The SAP execution guidance is unrelated to the tool's core behavior.

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

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

The description is verbose, with multiple paragraphs of SAP MCP context that are not specific to this tool. The first sentence is concise, but the rest is wasteful repetition, including the same text in the input schema description.

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 a simple purpose (close a position), but the description omits essential context like what wallet and positionKey represent, what happens on close (e.g., funds returned), and any important side effects. Output schema exists, but the description itself is incomplete for an agent to use confidently.

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 meaning beyond the schema; both parameters are simply 'Solana public key (base58)'. The description text does not explain these parameters further.

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

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

The description opens with 'Close a perpetual position on Adrena Protocol,' which clearly states the verb (close), resource (perpetual position), and protocol. It distinguishes from siblings like adrena_openPosition or adrena_addCollateral.

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

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

No usage guidance is provided. The description does not specify when to close a position vs. other actions, prerequisites, or alternatives. It only contains SAP MCP boilerplate that does not help with tool selection.

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

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

Annotations already declare readOnlyHint, idempotentHint, etc. The description adds valuable behavioral context: it is a 'paid read-premium', requires cost estimation first, and states that signer boundaries mean hosted reads don't receive keypair bytes. This goes beyond the annotations and helps the agent understand the invocation 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?

The description is verbose and repetitive, including the same SAP MCP execution guidance multiple times (in the description text and inside the input schema). The core purpose is front-loaded, but the repetitive boilerplate reduces conciseness significantly.

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

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

For a simple read tool with one parameter and an output schema, the description provides enough context about intent, pricing, and routing. However, it lacks differentiation from the sibling 'sap_adrena_get_positions', which is a notable gap given the extensive sibling list.

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 parameter 'wallet' is described as 'Solana public key (base58)'). The description does not add additional parameter semantics beyond what the schema already provides, 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 states 'Get all open positions on Adrena Protocol' with a specific verb and resource. However, it does not differentiate from the sibling tool 'sap_adrena_get_positions', which likely serves a similar purpose. The title and first sentence clearly indicate the tool's function.

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

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

The description lacks explicit guidance on when to use this tool versus alternatives like 'sap_adrena_get_positions'. It includes SAP MCP context about tool ecosystem and execution guidance (pricing, routing), but does not specify usage conditions or exclusions relative to siblings.

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

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

Annotations already indicate readOnlyHint=false, openWorldHint=true, idempotentHint=false, destructiveHint=false. The description adds no further behavioral details, such as prerequisites (e.g., wallet funding, approvals), success/failure outcomes, or side effects beyond what annotations 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 verbose with several paragraphs of SAP MCP boilerplate that is not tool-specific. The core purpose is only in the first sentence; the rest adds noise and reduces conciseness. More focused, tool-specific content would improve it.

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 complexity (8 parameters, 6 required) and the presence of an output schema, the description does not explain prerequisites like needing a signing wallet or sufficient balance. The annotations and schema partially cover it, but completeness is only adequate.

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

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

Schema coverage is 100% with good descriptions for each parameter (e.g., 'Market symbol (e.g. SOL, BTC, ETH)'). The tool description adds no additional semantic value beyond the schema, 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 'Open a leveraged perpetual position on Adrena Protocol,' specifying the verb (open) and resource (leveraged perpetual position). It distinguishes from siblings like closePosition and getPositions through naming, and the action is clearly different from build tools.

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

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

No guidance is provided on when to use this tool versus alternatives like sap_adrena_build_open_long or other Adrena tools. The extensive SAP MCP execution guidance is about pricing and routing within the framework, not about selecting this tool over others.

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, signaling this is a write operation with potential destructive effects. The description adds little beyond stating the action; it does not explain what happens to the position after removal, whether the operation is reversible, or any specific authorization requirements. The SAP MCP context covers execution details but not behavioral side effects.

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 a concise first sentence, but the second sentence is a long, generic paragraph about SAP MCP workflow that is not specific to this tool. This padding detracts from readability and focus. The tool definition could be significantly shortened by moving the generic SAP context 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?

Even though an output schema exists (and annotations provide some hints), the description does not explain the outcome of removing collateral, such as whether the position remains open or if funds are returned. For a destructive mutation tool, more context about side effects and safety considerations is needed to help the agent use it correctly.

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

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

The input schema has 100% coverage with clear descriptions for all three parameters (amount, wallet, positionKey). The description does not add any additional meaning or constraints beyond the schema. The baseline is appropriate here since the schema already handles parameter documentation adequately.

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', which is a specific verb+resource combination. This distinguishes it from sibling tools like adrena_addCollateral and adrena_closePosition. However, the purpose is somewhat buried under extensive SAP MCP context that is not directly about the tool's core 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 any guidance on when to use this tool versus alternatives, nor does it mention prerequisites or scenarios where the tool should be avoided. The SAP MCP context discusses pricing and routing but is generic and does not help an agent decide when to invoke this specific 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, idempotentHint, and destructiveHint. The description adds execution guidance (paid builder, estimate first, local finalization) and signer boundary details, which are 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 is verbose (120+ words) and repeats SAP MCP context that also appears in the input schema. While front-loaded with the core purpose, it could be more tightly scoped without losing essential 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 presence of an output schema and comprehensive annotations, the description covers the basic purpose, use case, and execution flow (pricing, routing, signer boundary). It is fairly complete for a read-only discovery 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. Description does not add additional meaning beyond what the schema provides (e.g., tld filter, wallet base58). No parameter-specific enhancements.

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 'domains owned by a wallet across all TLDs'. It distinguishes from siblings like alldomains_registerDomain and alldomains_resolveDomain by focusing on owned domains and discovery 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?

Description provides explicit context: 'Use as discovery context before choosing a name to associate with an agent.' It also includes SAP MCP execution guidance on pricing/routing. However, it does not compare to alternatives 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 discloses that this is a paid write operation requiring estimation and local signing, and that hosted accountless writes are blocked. Annotations (readOnlyHint=false) already indicate a write, but the description adds meaningful 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?

The description is verbose and repetitive, especially with SAP MCP execution guidance that appears both in the description and the input schema description. The first sentence is clear, but the rest is cluttered with platform-specific instructions, 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?

Given the output schema exists, the description adequately covers essential behavioral aspects (paid, requires local signer, blocked as hosted write). However, it lacks clarity on what the tool returns and the SAP-specific jargon may be opaque to agents not familiar with that platform.

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% coverage, so baseline is 3. The description adds minimal value, repeating schema examples (e.g., 'full domain (e.g. "myname.abc")') without deeper parameter semantics.

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 'Register a domain on AllDomains (supports multiple TLDs)' with specific TLD examples, distinguishing it from sibling tools like alldomains_getOwnedDomains and alldomains_resolveDomain.

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 single guideline: 'Use only when the requested name service is not SNS-specific.' It lacks explicit when-to-use or alternative recommendations. The majority of the text focuses on internal SAP routing, not 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 readOnlyHint, idempotentHint, and destructiveHint. The description adds that it resolves to owner wallet and does not change records, plus SAP MCP execution guidance about being a paid builder with signer boundary. This exceeds annotation but some guidance is generic.

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

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

The description is front-loaded with purpose but includes lengthy generic SAP MCP guidance that could be streamlined or referenced externally. Every sentence adds value, but the overall length reduces conciseness.

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

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

Given the output schema exists and schema coverage is 100%, the description covers purpose, usage, behavior, and execution guidance. It is complete for a simple resolution tool, though generic guidance could be separated.

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 single 'domain' parameter described as 'Full domain to resolve'. The description does not add further meaning beyond the schema, 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 the tool resolves a multi-TLD domain to its owner wallet, with specific verb 'resolve' and resource 'AllDomains name'. It explicitly distinguishes from SNS-specific resolution, differentiating it from siblings like sns_resolveDomain.

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 AllDomains name, not SNS-specific) and indicates it does not change ownership or records. Provides clear context for 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?

Description says 'operation class read' but annotations have readOnlyHint=false, creating a contradiction. Additionally, provides some behavioral info like signer boundary, 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?

First sentence is concise, but description includes extensive SAP MCP boilerplate that repeats multiple times, making it unnecessarily long. Could be trimmed to essential 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 presence of output schema, description sufficiently covers usage flow and prerequisites. However, does not address error conditions or limitations, and the contradiction reduces completeness.

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

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

Schema coverage is 100%, so baseline 3. Description adds that the tool builds and optionally wraps a URL, which is already implied by parameter names. No additional semantic depth beyond 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?

Description clearly states 'Build and optionally wrap a Solana Action URL for sharing as a Blink.' Specific verb and resource, and distinguishes from siblings like blinks_executeAction, blinks_getAction, etc.

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 for Solana Actions and Blinks metadata fetch, validation, and POST action preparation.' Also provides workflow steps: 'call sap_estimate_tool_cost first, then use sap_payments_call_paid_tool if the runtime cannot handle x402 natively.'

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

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

The description says 'operation class read' but the tool is clearly a write (sends a signature) and annotations have readOnlyHint=false. This is a direct contradiction, making the description 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 cluttered with SAP MCP boilerplate and redundant guidance, obscuring the core purpose. It is not concise and could be streamlined.

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 cover error states or response handling. The contradiction also undermines completeness.

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

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

Schema coverage is 100%, so the schema sufficiently documents the two parameters. The description adds no extra meaning beyond restating the parameter names.

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 the tool confirms a completed Solana Action by sending the tx signature back to the provider. This distinguishes it from sibling tools like blinks_executeAction or blinks_getAction.

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 vs alternatives. The description includes generic SAP MCP context that does not help select this tool over siblings.

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

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

Annotations already indicate destructiveHint true and openWorldHint true. The description adds behavioral context: it initiates a transaction but does not sign/submit itself, and it emphasizes previewing/validating outputs. 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 somewhat lengthy and repeats SAP MCP guidance both in the main text and input schema description. It front-loads the core purpose but could be more concise by avoiding duplication.

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 complexity and the presence of an output schema (not shown), the description covers workflow steps, prerequisites, routing constraints, and payment guidance. It is fairly complete for an agent to understand when and how to use the 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 mentions 'actionUrl (from getAction links)' which adds slight context, but otherwise does not significantly enhance parameter understanding beyond the schema descriptions.

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

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

The description clearly states that the tool executes a Solana Action by sending a wallet to an endpoint and receiving a transaction to sign. It distinguishes itself from sibling tools like blinks_getAction and blinks_confirmAction by specifying it handles the POST flow and involves signing.

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: use for Solana Action POST flow, confirm metadata/parameters/intent before invoking, preview and validate output before signing. It also includes routing constraints and integration with SAP payment tools, giving clear when-to-use and when-not-to-use 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, idempotentHint=true, destructiveHint=false. The description adds significant behavioral context beyond annotations: the intent is read/discovery, it mentions pricing (paid read-premium), routing (estimate cost first, then paid tool if needed), and signer boundary (hosted reads never receive keypair bytes). This provides valuable transparency for execution.

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

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

The description is front-loaded with purpose, followed by protocol context and usage guidance. It is well-structured but slightly redundant (pricing info appears in both description and input schema). Overall, it is concise and informative, earning a 4.

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 one-parameter readonly tool with output schema present, the description is complete. It explains what the tool returns, when to use it, and execution specifics (pricing, routing, signer boundary). No gaps remain.

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 a clear description for actionUrl: 'Solana Action URL (https endpoint implementing the Actions spec).' The tool description does not add further parameter details beyond what the schema already provides. Baseline 3 is appropriate since schema does the heavy lifting.

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 'Fetch metadata for a Solana Action (Blink) — returns title, description, available actions, and parameters.' The verb 'fetch' and resource 'metadata for a Solana Action (Blink)' are specific. It distinguishes from sibling tools like blinks_buildActionUrl (building URLs) and blinks_executeAction (execution), making the purpose unambiguous.

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

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

The description provides explicit use cases: 'Use for Solana Actions and Blinks metadata fetch, validation, and POST action preparation. Preview and validate actions before signing or submitting transactions through SAP transaction tools.' This guides when to use the tool, though it does not explicitly list when not to use or name alternative tools for other scenarios. However, the sibling list implies 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 already declare readOnlyHint=true, non-destructive. Description adds context about pricing (paid hosted call), routing, signer boundary (no keypair bytes), and operation class (read), which goes 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 front-loaded with the key purpose, but includes verbose SAP MCP execution guidance that is repeated in the schema. Could be more concise by separating generic guidance.

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 output schema exists and annotations cover safety, the description covers purpose, usage, pricing, routing, and signer boundary. It is complete for a resolution tool, though minor edge cases (e.g., invalid URL handling) are not mentioned.

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 already describes blinkUrl with an example. The tool description essentially repeats the example without adding new meaning, so it adds no value beyond schema.

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

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

The description clearly states the tool resolves a Blink URL to its underlying Solana Action URL, distinguishes it from siblings by mentioning preview/validation before signing, and specifies use for metadata fetch and POST action preparation.

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

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

Provides explicit guidance on when to use (for Blinks metadata fetch, validation, POST action preparation), mentions SAP MCP execution workflow, pricing as paid read-premium, and instructions to estimate and use sap_payments_call_paid_tool when needed.

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

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

The description adds behavioral context beyond annotations, such as 'operation class read' and the signer boundary note: 'hosted reads/builders never receive keypair bytes; value-moving results must be finalized locally when signing is required.' Annotations only indicate readOnlyHint=false, so the description adds valuable 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 useful information but is verbose, especially with repeated SAP MCP execution guidance that appears in both the description and schema. The core purpose is stated early, but extra guidance could be condensed.

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 only one parameter and the presence of an output schema, the description sufficiently covers the validation purpose. It mentions 'checks if a website correctly implements the Solana Actions spec,' which is complete enough for an agent to understand the tool's role.

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 one parameter (domain) with a description. Schema coverage is 100%, so the description does not need to add much. It does not elaborate on domain format beyond the schema's example. 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. It uses specific verb-resource phrasing ('Validate a domain's actions.json file') and differentiates from sibling tools like blinks_buildActionUrl and blinks_getAction by focusing on validation.

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 when to use this tool: 'for Solana Actions and Blinks metadata fetch, validation, and POST action preparation' and 'preview and validate actions before signing or submitting transactions.' While it does not explicitly state when not to use it, it gives clear situational 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 destructiveHint=true and readOnlyHint=false. The description adds context about confirming parameters and finality expectations, but does not disclose side effects or what gets destroyed. The SAP MCP boilerplate does not add behavioral 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 verbose with multiple paragraphs of repetitive SAP MCP execution guidance that could be externalized. The core purpose is front-loaded, but the rest is cluttered and not 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 the presence of an output schema and high parameter coverage, the description covers core purpose and post-submission status checking. However, it lacks details on return types, failure modes, and gas estimation, leaving gaps for a complex bridge 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 new meaning beyond the schema; it only reiterates the need to confirm parameters, which is more usage guidance than parameter semantics.

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 bridges tokens across chains via deBridge DLN with deterministic pricing. It distinguishes from siblings like bridging_bridgeWormhole and bridging_bridgeDeBridgeStatus.

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 using the tool for cross-chain asset movement and calling the status tool after submission, but does not explicitly compare to bridging_bridgeWormhole or provide when-not-to-use guidance. The extensive SAP MCP context is generic and not tool-specific.

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 claims 'Check the status' (read-only behavior), but annotations set readOnlyHint=false and destructiveHint=true, contradicting the described read nature. No additional behavioral context beyond this 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?

Core purpose is concise (one sentence), but includes lengthy execution guidance boilerplate that may be redundant. Could be trimmed without losing 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?

Covers basic usage context and execution guidance, but lacks details on output format (though output schema exists) and fails to address the annotation contradiction. 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 coverage is 100% with clear parameter description 'deBridge DLN order ID'. Description does not add extra info beyond schema; baseline 3 applies.

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

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

Description explicitly states 'Check the status of a deBridge DLN cross-chain transfer' with clear verb and resource. It distinguishes from sibling tools like bridging_bridgeDeBridge (submit) and bridging_bridgeWormholeStatus (different protocol) by 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?

Directs to 'Call this after bridging_bridgeDeBridge and keep the resulting status with the user-facing bridge audit trail.' Clearly defines when to use, but does not explicitly mention when not to use or 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 destructiveHint:true, and the description reinforces this by labeling it a 'write' operation. It adds behavioral detail beyond annotations, such as routing restrictions ('hosted accountless write is blocked'), signer boundary requirements, and the need to check fees and finality. This provides valuable context for safe invocation.

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 lengthy and contains repetitive SAP MCP context (e.g., 'SAP MCP context: Protocol bridging; operation class write' appears twice in different forms). While the first sentence effectively states the purpose, the overall verbosity could be trimmed for clarity without losing essential guidance.

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 complex cross-chain bridge with an output schema (not shown). The description covers purpose, usage, behavioral constraints, and post-submission steps (calling status tool). For a write tool requiring user signing and careful parameter confirmation, it provides sufficient context for an agent to use it correctly.

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

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

Schema description coverage is 100%, so the input schema already documents all 7 parameters with descriptions. The description lists the parameters to confirm (source chain, destination chain, token, amount, etc.) but does not add new semantic detail 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 opens with 'Bridge tokens across chains via Wormhole. Supports Solana ↔ EVM chains.' This clearly states the action, resource, and protocol, and distinguishes the tool from its sibling bridging_bridgeDeBridge (different protocol) and bridging_bridgeWormholeStatus (status check). The purpose is 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 advises to 'confirm source chain, destination chain, token mint, amount, recipient, route fees, and finality expectations before invoking a bridge write' and to 'call the matching status tool after submission.' This provides clear context for when and how to use the tool, though it does not explicitly exclude alternatives like deBridge when Wormhole is not appropriate.

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 this is a read-only status check, but annotations have destructiveHint: true and readOnlyHint: false, directly contradicting the described behavior. This is a critical inconsistency that misleads the agent about the tool's side effects.

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 core description is concise, but it includes extensive boilerplate SAP MCP execution guidance (pricing, routing, signer boundary) that is not directly about the tool's function. This extra information dilutes clarity and could be moved to a separate field.

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

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

For a simple status check with two parameters and an output schema, the description covers the primary use case. However, the annotation contradiction undermines completeness regarding behavioral expectations, and the extraneous guidance adds noise.

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 description adds meaningful context beyond the schema: it explains that 'sequence' is the 'Wormhole sequence number from bridgeWormhole response' and 'sourceChain' is the 'Source Chain parameter for Bridging Bridge Wormhole Status.' This clarifies the origin and usage of 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 'Check the status of a Wormhole bridge transfer.' It specifies the tool's purpose with a specific verb and resource, and implicitly distinguishes it from sibling tools like bridging_bridgeWormhole (submission) and bridging_bridgeDeBridgeStatus (different bridge).

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 to check Wormhole bridge transfer status after a bridge submission. Call this after bridging_bridgeWormhole.' It offers a clear when-to-use but lacks explicit when-not-to-use or alternatives beyond the sibling 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, destructiveHint, etc. The description adds context about pricing (paid read-premium), routing, and signer boundary, which go 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 is lengthy due to SAP-specific instructions, which may be unnecessary for general use. It is structured but 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 the output schema exists, return values are covered. The description covers purpose, usage context, and behavioral notes adequately for a tool with 3 parameters and full schema coverage.

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% coverage with descriptions for each parameter. The tool description does not add 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 explicitly states 'Get OHLCV (price chart) data from CoinGecko', providing a specific verb and resource. It distinguishes the tool from siblings like coingecko_getTokenPrice and coingecko_getTokenInfo by specifying OHLCV 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 indicates use for off-chain market data and clarifies that on-chain data is authoritative, giving context. However, it does not explicitly state when not to use this tool or list alternatives among 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 read-only and idempotent. The description adds that data is 'off-chain market data' and 'advisory context', which is useful behavioral context. It also mentions pricing as 'paid read-premium'. 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 significantly longer than necessary due to repetitive SAP MCP execution guidance that appears generic. The core purpose is front-loaded, but the boilerplate adds clutter.

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 that an output schema exists, the description adequately states the primary function. However, it lacks details about pagination or network handling beyond what the schema provides. The SAP-specific content does not enhance domain completeness.

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

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

Input schema has 100% coverage with descriptions for all three parameters (page, network, tokenAddress). The tool description does not add additional meaning beyond the schema, so 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 first sentence clearly states 'Get all liquidity pools for a token' with a specific verb and resource. This distinguishes it from sibling coingecko tools like getTokenPrice and getTokenInfo. However, the purpose is somewhat obscured by extensive SAP MCP boilerplate.

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 groups this tool with other market data tools ('token prices, trending assets, token info, pools, and OHLCV') but does not explicitly state when to use this tool over alternatives. The SAP execution guidance is about how to call, not when to choose.

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, so the description adds limited new behavioral context. It notes the tool is paid and provides SAP execution guidance, but does not contradict annotations.

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

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

The description includes a long block of SAP MCP execution guidance that is boilerplate and not specific to this tool. This makes it verbose and not concise. The core purpose is stated in one sentence, but the additional text reduces clarity.

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 input schema and existence of output schema, the description covers the basic purpose and adds pricing context. However, it lacks guidance on how to find token IDs and does not help the agent choose among sibling coingecko tools, leaving some 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?

The input schema covers the single required parameter tokenId with 100% coverage. The description does not add any additional meaning beyond the schema's description 'CoinGecko token ID', 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 the tool retrieves detailed token information from CoinGecko, including description, links, and market data. However, it does not explicitly distinguish this tool from other coingecko tools like getTokenPrice or getTrending, which are listed as siblings.

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 using the tool for off-chain market data but does not provide explicit guidance on when to use this tool versus alternatives. No alternatives or exclusions are given, making it hard for an agent to decide between this and specialized coingecko 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, idempotentHint, etc. The description adds execution guidance (free pricing, direct call, signer boundary) which is valuable but not contradictory. No additional behavioral traits beyond annotations are disclosed.

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 structured with clear sentences and bullet points. Repetition of execution guidance in the input schema description adds some redundancy, so not maximally 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?

Covers purpose, usage, execution context, and limitations (advisory vs. on-chain). With output schema present, return values are documented. Missing specifics on rate limits or fallback behavior, but generally complete given 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% with clear parameter descriptions. The description adds a warning to use exact field names but does not enhance semantic understanding 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 'Get token price and market data from CoinGecko' and lists use cases (token prices, trending assets, etc.). However, it overlaps with sibling tools like coingecko_getTokenInfo and coingecko_getOHLCV without explicit differentiation, making it slightly less precise.

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 clear when-to-use guidance for off-chain market data and notes that on-chain state is authoritative for payments. Includes pricing and routing advice. However, does not explicitly compare to sibling tools or say when not to use this tool in favor of a more specialized one.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false. The description adds 'operation class read' and 'read/discovery workflow', which are consistent but do not substantially expand beyond annotations. No contradictions. No details on rate limits, data freshness, or the exact meaning of 'top gainers/losers' (e.g., percentage change calculation).

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 suffers from excessive SAP MCP boilerplate that is repeated in multiple places, including the input schema. The first sentence is concise, but the rest is long and cluttered with operational details (pricing, routing, signer boundary) that are better suited for documentation or system-level configuration. Every sentence does not earn 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 simple with 2 params and an output schema exists, but the description lacks critical details: what the output contains (e.g., list of tokens with price change), sorting order, count of items, and whether vsCurrency is required. Without these, an agent may not understand the tool's full behavior. The SAP context is irrelevant to the functional completeness.

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

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

Schema description coverage is 100%, but the descriptions are tautological (e.g., 'Duration parameter for Coingecko Get Top Gainers Losers'). The main description does not explain the parameters further. It does not clarify that vsCurrency is a base currency like 'usd' or what the duration values represent. The param semantics are not improved by the 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 'Get top gainers and losers from CoinGecko' which identifies the specific resource and action. The title and first sentence are unambiguous. However, the following SAP MCP text dilutes the clarity by mixing operational details with the core purpose. Sibling tools include other coingecko_* functions, so the tool is distinguishable as focused on gainers/losers.

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

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

The description offers vague advisory like 'Use for off-chain market data' without specifying when to prefer this tool over alternatives like coingecko_getTrending or coingecko_getTokenPrice. It does not mention exclusion criteria or alternative tools. The SAP routing info is not about usage context but about payment/execution mechanics.

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

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

Annotations already indicate readOnlyHint=true and destructiveHint=false. The description adds 'operation class read' and 'paid read-premium' pricing, providing cost context beyond schema. 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 includes lengthy SAP MCP boilerplate that is duplicated in the input schema, making it verbose. The functional purpose is front-loaded, but the repetitive execution guidance detracts from 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?

The tool has no parameters and an output schema exists, so output details are not required. The description includes integration guidance (e.g., estimating cost) but omits any detail about the return format or structure, leaving some 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?

With zero parameters, the schema fully describes the interface. The description adds no param info, which is acceptable as baseline is 4 for no-parameter tools.

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

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

The description clearly states 'Get trending tokens and NFTs on CoinGecko', identifying the specific resource and action. However, it does not explicitly distinguish from sibling tools like coingecko_getTokenPrice or coingecko_getTokenInfo, relying on the tool name for differentiation.

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 it for off-chain market data as advisory context and notes that on-chain state is authoritative. It implies usage context but lacks explicit when-to-use or when-not-to-use comparisons with other 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, idempotentHint, etc. The description adds valuable behavioral traits: pricing (paid read-premium), routing (hosted call, need to estimate first), and signer boundary (no keypair bytes). These go beyond annotations and are critical for agent execution.

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 starts clearly but then includes a confusing line about discovery by multiple criteria, which is not concise. The execution guidance is repeated in the schema description, adding redundancy. It could be trimmed and better structured for clarity.

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-only, has output schema), the description is fairly complete. It covers key behavioral aspects like pricing and routing that are not in annotations or schema. It lacks details on errors or rate limits but overall 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 'id' described as 'Asset mint address'. The description does not add extra meaning beyond this, such as format or examples. Baseline is 3 due to high schema coverage.

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

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

The description clearly states 'Get detailed information about a single NFT/asset via DAS', specifying the verb and resource. It distinguishes from sibling tools like das_getAssetsByOwner etc. by focusing on a single asset. The mention of protocol and operation class adds clarity.

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

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

The description suggests using the tool for 'discovery by owner, creator, collection, or search query', which is inconsistent with its single-asset purpose. It does not explicitly state when to use this tool versus sibling das_* listing tools. The repetitive SAP execution guidance provides operational context but lacks clear when-to-use versus 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 already indicate readOnlyHint=true, destructiveHint=false, idempotentHint=true. The description adds value by detailing the read/discovery workflow, pricing model, and signer boundary (e.g., 'hosted reads/builders never receive keypair bytes'), providing transparency beyond the annotations.

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

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

The description is verbose and contains redundant SAP boilerplate that is also repeated in the input schema description. The core purpose is concise, but the overall text is long and unfocused, which detracts from clarity.

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 burden on the description is reduced. However, the description does not explain what the tool returns (e.g., structure of assets) and instead fills space with SAP context. It is adequate but not fully 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?

Input schema coverage is 100%, but the descriptions are tautological (e.g., 'Page pagination control for Das Get Assets By Collection') and the collectionAddress description is misleading ('NFT mint address'). No additional meaning beyond the schema is provided; in fact, it introduces inaccuracy.

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 states 'Get all NFTs in a collection via DAS' which is clear, but then expands to 'by owner, creator, collection, or search query', conflating this tool with siblings that are specifically for those other query types. The parameter description for collectionAddress incorrectly labels it as an 'NFT mint address' rather than a collection address, 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 use for read-only discovery and to prefer DAS reads over Metaplex writes, which is helpful. However, it does not explicitly distinguish when to use this tool versus the similar siblings (das_getAssetsByOwner, etc.), and the SAP-specific pricing and routing guidance, while possibly useful, is not typical usage guidance.

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

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

Annotations already indicate read-only, idempotent, and non-destructive. The description adds valuable context: paid read-premium, cost estimation requirements, signer boundary (no keypair bytes), and hosted read nature, going 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 somewhat repetitive, especially the SAP MCP execution guidance which appears verbatim in both the description and schema. It could be more concise by removing duplication and focusing on unique content.

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

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

With an output schema present, the description adequately covers the tool's purpose, protocol, class, and execution guidance. It doesn't elaborate on output details or prerequisites, but given the output schema, completeness 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%, and each parameter has a description in the schema. The main description does not add extra meaning about parameters beyond what is already in the schema, 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 it retrieves NFTs/assets by creator via DAS, with a specific verb and resource. However, it briefly mentions broader discovery use cases (owner, collection, search) that could blur boundaries with sibling tools like das_getAssetsByOwner or das_searchAssets.

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 guidance (prefer DAS reads over Metaplex writes) and execution workflow details, but lacks explicit comparison with sibling DAS tools or conditions for 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 and destructiveHint false. The description adds valuable context such as DAS protocol, operation class read, pagination support, and payment routing guidance. It does not contradict annotations and provides useful behavioral details beyond the structured fields.

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 redundancy, particularly the repeated SAP MCP execution guidance that also appears in the input schema. The initial sentence is effective, but the overall text is longer than necessary and could be more compactly structured.

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

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

Given the presence of an output schema and high schema coverage, the description adequately covers purpose, usage, and behavioral context. It includes payment routing and signer boundary information, but lacks specifics on error conditions or rate limits.

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 input schema describes each parameter clearly. The description adds minimal additional meaning beyond mentioning pagination (relates to page, after, before, limit). Baseline 3 is appropriate as the description does not significantly enhance 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 retrieves NFTs/assets owned by a wallet via DAS and supports pagination. It distinguishes from sibling tools like das_getAssetsByCollection and das_getAssetsByCreator by focusing on owner-based retrieval.

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

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

The description provides clear context for when to use the tool (read-only DAS discovery) and expresses preference for DAS reads before Metaplex writes. However, it does not explicitly exclude when not to use it or mention alternative tools for write operations.

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, openWorldHint, idempotentHint, and destructiveHint. The description adds valuable behavioral context: pricing is 'paid read-premium' with an estimate-first workflow, and signer boundary notes that hosted reads never receive keypair bytes. 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 somewhat verbose, repeating SAP MCP context and pricing details that also appear in the input schema description. It is structured but could be more concise by removing redundancy.

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

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

Given the complexity (9 optional parameters, output schema exists), the description covers purpose, usage, behavioral traits, pricing, and signer boundary. It is largely complete, though error handling and response structure are not mentioned (but output schema covers the latter).

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 each parameter has a description. The tool description mentions filter types (owner, creator, collection, search query) but does not add meaning beyond what the schema already provides. Baseline is appropriate at 3.

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

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

The description clearly states the tool searches NFTs/assets with flexible filters via DAS, and specifies use cases (owner, creator, collection, search query). It distinguishes DAS reads from Metaplex writes, but does not explicitly differentiate from similar sibling tools like das_getAssetsByOwner or das_getAsset, leaving some ambiguity about when to use this general search versus those specific tools.

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

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

The description gives clear context for when to use this tool ('use for read-only DAS NFT and asset discovery') and a preference for DAS reads before Metaplex writes. However, it does not explicitly state when not to use it or mention alternatives like das_getAsset for single asset retrieval, leaving room for improvement.

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 adds context beyond annotations by mentioning on-chain escrow, write operation class, and the need to confirm scope/payout before execution. It aligns with annotations (readOnlyHint=false, destructiveHint=false) and provides useful warnings.

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 front-loads the purpose but then includes extensive SAP MCP execution guidance that is verbose and could be summarized or placed in a separate field. It is not optimally concise for agent consumption.

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 annotations, the description covers the core behavioral traits. However, it misses some aspects like the exact outcome of creation (e.g., transaction confirmation) and assumes familiarity with SAP infrastructure.

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 parameters are already explained. The description does not enhance parameter understanding beyond the schema, meeting 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 first sentence clearly states the tool creates a bounty with on-chain escrow. However, the subsequent claim 'Use for bounty creation, listing, and work submission' is inaccurate and may confuse agents about the tool's primary function versus sibling tools.

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

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

The description lacks explicit guidance on when to use this tool vs. siblings like 'gibwork_listBounties' or 'gibwork_submitWork'. It incorrectly suggests it covers listing and work submission, which are separate tools, and does not provide conditions or 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 already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the agent knows this is a safe, non-destructive operation. The description adds some operational context (e.g., pricing, routing, signer boundaries) but does not describe behavior like pagination, filtering, or response format. With annotations covering safety, this is adequate but not thorough.

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 excessively long due to repeated SAP MCP boilerplate (routing, pricing, signer boundaries), which is also present in the input schema. This padding detracts from conciseness and buries the core purpose. A single sentence would suffice; the current text wastes space.

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 three optional parameters and existence of an output schema, the description provides minimal context beyond the basic listing function. It does not explain how the parameters affect results or how to interpret the output. However, with strong annotations and full schema coverage, the missing details are not critical.

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

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

Schema coverage is 100%, so all parameters (tags, limit, status) are fully described in the schema. The description does not add any extra meaning or usage guidance for parameters beyond what the schema provides. The baseline of 3 applies because the schema handles parameter documentation.

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

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

The first sentence clearly states the tool's purpose: 'List available bounties on Gib Work.' This distinguishes it from sibling tools like gibwork_createBounty and gibwork_submitWork, which handle creation and submission. The verb 'list' and resource 'bounties' 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 provides no explicit guidance on when to use this tool versus alternatives. It includes vague statements like 'Use for bounty creation, listing, and work submission,' which conflates multiple tools and does not help the agent decide when to invoke listBounties specifically. No criteria for selecting this tool over others 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 set destructiveHint=true, indicating a write operation. The description adds detailed behavioral context: pricing (paid read-premium), routing restrictions (hosted accountless write blocked), and signer requirements (user-controlled signing). This goes beyond annotations, though it is heavily focused on SAP MCP execution specifics.

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 lengthy and includes repetitive SAP MCP boilerplate that distracts from the core purpose. While the first sentence is front-loaded well, the subsequent paragraphs are verbose and could be condensed significantly without losing essential guidance.

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 write operation with destructive potential, the description adequately covers constraints (pricing, routing, signing) and required inputs. An output schema exists so return value explanation is unnecessary. The mention of using SAP attestation/feedback tools provides post-submission 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%; all four parameters have descriptions. The description does not add significant parameter-level meaning beyond the schema, offering only a general note to 'confirm scope, payout, recipient, and deliverable evidence before writes.' Baseline 3 applies because the schema carries the burden.

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 begins with 'Submit completed work for a Gib Work bounty,' which clearly states the action (submit) and the resource (work for a bounty). It distinguishes itself from sibling tools like gibwork_createBounty (creation) and gibwork_listBounties (listing).

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 using the tool 'for bounty creation, listing, and work submission,' which conflates multiple operations—the tool is specifically for submission. It also suggests using SAP attestation or feedback tools after work completion, but does not explicitly exclude this tool from those contexts or provide clear 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. The description adds valuable context: it is a paid read tool ('pricing: paid read-premium'), requires cost estimation, and explains the signer boundary. This goes beyond 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 front-loaded with the core purpose. It then follows a structured approach with SAP MCP context and execution guidance sections. However, there is some redundancy (the execution guidance appears also in the input schema description) and it is longer than necessary for a simple status check 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?

The description covers purpose, SAP context, pricing, routing, and signer boundary. Given that an output schema exists (not shown but indicated), it does not need to explain return values. It is sufficient for an agent to understand how to use it within the SAP environment, though it could be more specific about when to use it (e.g., after sending a bundle).

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 does not add any further semantics to the bundleId parameter beyond what the schema already states ('Bundle ID parameter...'). The parameter meaning is clear 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 first sentence 'Check the status of a submitted Jito bundle' uses a specific verb ('check') and resource ('status of a submitted Jito bundle'), clearly differentiating it from sibling tools like jito_sendBundle (submit) and jito_getTipEstimate (tip info). The purpose is immediately evident.

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 execution guidance about pricing and routing, which aids in usage context, but it does not explicitly state when to use this tool versus alternatives (e.g., after jito_sendBundle). The guidance is implicit and more about how to operate within the SAP ecosystem rather than when to choose this specific 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 and idempotentHint=true. The description adds that it is a 'paid read-premium' and 'hosted reads/builders never receive keypair bytes', providing additional 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?

The description is front-loaded with the tool's purpose but includes lengthy SAP MCP boilerplate that repeats the same guidance in both the description and input schema. While informative, it 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?

The description does not specify the format or fields of the returned tip estimates, though an output schema exists. It mentions 'bundle inclusion priority' but leaves gaps in what the agent can expect.

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

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

The tool has zero parameters and the schema description coverage is 100%, so no additional parameter information is needed. The baseline score of 4 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 states 'Get current Jito tip percentile estimates for bundle inclusion priority', which uses a specific verb and resource, clearly distinguishing it from sibling tools like jito_getBundleStatus and jito_sendBundle.

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 and execution guidance, such as 'Intent: read/discovery workflow' and 'Pricing: paid read-premium', and advises when to use sap_payments_call_paid_tool as an alternative. This provides clear context for usage, though it is slightly verbose.

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 the tool is not read-only, not destructive, and not idempotent. The description adds 'atomic transaction execution' and 'MEV-protected' but does not detail side effects, limits, or failure modes. It provides some value beyond annotations but remains incomplete.

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 overly long with extensive SAP MCP context that is tangential to the core tool function. The first sentence is concise, but subsequent sentences add clutter, reducing overall clarity for an AI agent.

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 complexity of sending bundles and the presence of an output schema (though not shown), the description covers the basic purpose but omits key details such as success criteria, error handling, and confirmation guarantees. It is 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%, with both parameters (tipLamports and transactions) described clearly in the schema. The description adds no additional meaning or constraints beyond what the schema already provides, meeting 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 clearly states 'Send a Jito bundle for MEV-protected, atomic transaction execution.' It uses a specific verb and resource, and differentiates from sibling tools like jito_getBundleStatus 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?

The description lacks explicit guidance on when to use this tool versus alternatives. While it includes SAP MCP context about payment routing and signing, it does not explain when to choose Jito bundles over individual transactions or other MEV protection methods.

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 (cancellation) and readOnlyHint=false. The description adds that it creates an unsigned transaction (not executed directly), describes pricing as 'paid value-action' requiring preview, and states hosting constraints. This goes beyond annotations by clarifying the need for user signing and the unsigned nature of the output.

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 verbose with repeated SAP MCP boilerplate in both the description and input schema description. While the first sentence is clear and front-loaded, the repetition makes it less concise. It could be trimmed by 30-40% without losing essential 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 that an output schema exists and parameters are straightforward, the description adequately covers purpose, workflow, constraints (blocked hosted writes), and post-tool actions (preview/sign). It provides sufficient context for an agent to understand when and how to use this tool within the SAP ecosystem.

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 self-explanatory descriptions for all 4 parameters. The description adds a note about using exact field names and avoiding private key material, but does not enrich meaning beyond the schema. Baseline 3 is appropriate for high schema coverage.

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

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

The description clearly states 'Create an unsigned transaction to cancel a DCA recurring order.' It uses a specific verb (cancel) and resource (DCA recurring order), and distinguishes from sibling tools like jupiter_createDCA, jupiter_executeDCA, and jupiter_getDCAOrders by specifying cancellation and unsigned transaction generation.

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 extensive workflow context: Jupiter tools are for quote/route/swap, then use SAP transaction preview/sign/submit tools for signing. It explicitly warns against calling this as a paid hosted write and directs to local bridges or unsigned builders when signing is required. However, it does not contrast with other Jupiter cancel tools (e.g., jupiter_cancelLimitOrder) but the overall guidance 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 flag destructiveHint=true and readOnlyHint=false, but the description adds critical context: the tool creates an unsigned transaction, not a submitted one, and includes routing and signer boundary guidance. This is beyond what annotations provide, though some boilerplate is generic.

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 verbose with generic SAP MCP boilerplate that repeats across Jupiter tools. The first sentence is concise, but the subsequent paragraph adds unnecessary length without tool-specific 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 output schema exists, the description does not need to detail return values. It explains the unsigned transaction nature and SAP MCP workflow sufficiently. However, it lacks some specifics like error handling for non-existent orders.

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 parameter descriptions for maker, order, and computeUnitPrice. The tool description adds no additional parameter meaning, 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 opens with 'Create an unsigned transaction to cancel a specific limit order,' which is a specific verb+resource combination. It clearly distinguishes from sibling tools like jupiter_cancelLimitOrders (plural) and jupiter_cancelDCA by targeting a single limit order.

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 general SAP MCP workflow guidance but does not explicitly compare this tool to alternatives like jupiter_cancelLimitOrders or provide when-not-to-use conditions. Usage is implied from the name and first sentence, but no explicit guidance 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?

The description adds important behavioral context beyond annotations: it clarifies that the tool only 'creates unsigned transactions' (does not execute) and cancels in batch. Annotations already mark it as destructive (destructiveHint=true) and not read-only. The description supplements this with the unsigned transaction detail.

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 excessively long with generic SAP MCP boilerplate that appears repeated across tools. The core purpose is stated in the first sentence, but the remainder is verbose and detracts from conciseness. It could be significantly shortened.

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 key behavioral aspect (unsigned transaction) and batch cancel, and output schema exists. However, it lacks details on error conditions, prerequisites, or return information. The boilerplate provides generic workflow context but does not tailor to this tool's specifics.

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 description does not need to add parameter semantics. It mentions 'batch' but that is already implied by the array type. The description does not provide additional meaning for parameters like computeUnitPrice 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 that the tool's purpose is to create unsigned transactions to cancel multiple limit orders in batch. This specific verb-resource pairing ('create unsigned transactions', 'cancel multiple limit orders') distinguishes it from siblings like jupiter_cancelLimitOrder (singular) 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?

The description provides high-level workflow context (quote/route/swap then use preview/sign/submit), but does not explicitly state when to use batch cancel vs singular cancel or other alternatives like jupiter_cancelDCA. The guidance is implicit from the name but not spelled out.

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 a write operation (readOnlyHint=false). The description adds significant behavioral context: it returns an unsigned transaction, is a paid value-action requiring user confirmation, and cannot be used as a hosted write. This goes 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 lengthy with SAP-specific context that could be more concise. It includes redundant sections (SAP MCP context vs execution guidance). While front-loaded with the main purpose, the overall structure is somewhat 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 that an output schema exists, the description adequately covers the tool's purpose, return type (unsigned transaction), and its role in the SAP workflow (pricing, routing, signer boundary). It is complete for the intended use case.

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

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

Input schema has 100% description coverage, so the schema already documents all parameters. The description adds a note to use exact field names and avoid private key material, but does not provide additional semantic meaning beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states 'Create a Dollar-Cost Averaging (DCA) recurring order. Returns an unsigned transaction.' This is a specific verb+resource combination, and it distinguishes itself from sibling tools like jupiter_cancelDCA and jupiter_executeDCA.

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 on when to use this tool within the SAP MCP workflow, mentioning it returns an unsigned transaction and should be paired with preview/sign/submit tools. However, it lacks explicit guidance on when to choose DCA over other order types like limit orders or swaps.

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

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

Beyond annotations (which indicate a writable, non-idempotent operation), the description discloses that the tool returns an unsigned transaction, is paid ('pricing: paid value-action'), and has routing restrictions ('hosted accountless write is blocked'). This provides crucial behavioral context the agent needs.

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 front-loaded, but the description includes repetitive SAP context text (the same 'Intent: SAP MCP tool workflow...' block appears both here and in the input schema). While informative, this duplication makes the description unnecessarily long.

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 (9 parameters, 6 required, output schema exists), the description covers the essential workflow (returns unsigned transaction, signing via executeTrigger, pricing, routing) and SAP integration context. It does not need to explain return values since an output schema is provided.

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 each parameter is documented in the schema. The description adds only a minor note about using exact field names and avoiding private key material. This aligns with the baseline expected for high schema coverage.

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

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

The description clearly states 'Create a limit order. Returns an unsigned transaction.' This specifies the action (create), resource (limit order), and output (unsigned transaction), distinguishing it from sibling Jupiter tools such as jupiter_cancelLimitOrder or jupiter_createDCA.

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 instructs to sign and submit via executeTrigger and provides comprehensive SAP MCP execution guidance, including when to use this tool (for quote/route/swap preparation) and when to switch to SAP transaction preview/sign/submit tools. It also covers routing restrictions and billing 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. Description adds context about pricing (paid value-action), requirement for user confirmation, and routing restrictions. Though some SAP MCP boilerplate is present, it provides meaningful behavioral insight 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 front-loaded with the core action, but includes extensive SAP MCP context that, while relevant, makes it verbose. It is structured logically.

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 adequately covers the workflow (after createDCA), pricing, and routing. It tells the agent what not to do and when to use alternative tools.

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 100% of parameters. The description repeats the parameter descriptions from the schema without adding new semantics or usage nuances beyond 'signedTransaction' and 'requestId'.

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 submits a signed DCA order creation/cancellation transaction. It uses specific verbs and resources, distinguishing it from siblings like jupiter_cancelDCA and jupiter_createDCA.

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

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

Provides explicit guidance on when to use this tool (for signed DCA transactions) and when not to (do not call as a paid hosted write, no x402 payment). Recommends alternatives like local sap_payments bridge or hosted unsigned builder for unsigned transactions.

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 context: hosted accountless write is blocked, no x402 payment should be charged, and signer boundary details. This goes beyond annotations to explain behavioral constraints and routing implications.

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 multiple sentences but each adds value: purpose, workflow guidance, routing restrictions. It is front-loaded with the core action, though could be slightly 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 the tool's complexity (swap execution, SAP MCP context, payment routing), the description covers source of transaction, output (execution status), routing restrictions, and signer boundary. Output schema exists, so return values need not be detailed.

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 (requestId, signedTransaction). The description adds context that signedTransaction comes from getOrder, enhancing understanding beyond the schema.

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

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

The description clearly states the tool executes a signed swap transaction from getOrder and returns execution status. It distinguishes itself from related tools like getOrder and SAP transaction tools, establishing its specific role in the workflow.

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: use after getOrder for swap execution, but switch to SAP transaction preview/sign/submit tools when unsigned transactions need signer policy. It also warns against calling as a paid hosted write and clarifies x402 payment restrictions.

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 a mutation is expected. The description adds valuable behavioral context: it submits a transaction for on-chain execution, involves 'paid value-action', requires user confirmation, and is non-custodial. This goes beyond what annotations provide, though some redundancy exists with the input schema description.

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 overly verbose, with a large block of repetitive SAP MCP context that appears both in the description and the input schema. The core purpose is stated concisely in the first sentence, but the rest is bloated and contains redundant instructions. This diminishes clarity and wastes tokens.

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 (2 parameters) and the presence of an output schema, the description adequately covers the high-level workflow. It explains the execution chain and signer requirements. However, it omits details about the return value or how to verify success, though these may be covered by the output 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?

Input schema coverage is 100% with descriptions for both parameters. The description does not add meaningful new information beyond the schema; it repeats the same SAP MCP boilerplate text. The baseline score of 3 is appropriate because the schema already carries the parameter semantics.

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 submits a signed limit-order transaction for on-chain execution. The verb 'submit' and resource 'signed limit-order transaction' are specific. However, it does not explicitly distinguish itself from sibling tool 'jupiter_executeOrder', which likely serves a similar but different purpose (e.g., market orders). This lack of differentiation prevents a score of 5.

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

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

The description provides extensive but misdirected guidance about SAP MCP execution workflow, but fails to address when to use this tool versus alternatives like jupiter_executeOrder or jupiter_cancelLimitOrder. It does not mention prerequisites such as requiring a previously created limit order or that the transaction must be signed by the user. The agent is left without clear decision logic.

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

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

Annotations already indicate readOnlyHint=true, destructiveHint=false, idempotentHint=true. The description adds valuable context: 'Pricing: paid read-premium' and 'Signer boundary: hosted reads/builders never receive keypair bytes.' 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 front-loaded with the main purpose in the first sentence. It includes necessary SAP MCP context, which, while verbose, is relevant. It could be slightly more concise, but overall well-structured.

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

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

Given the tool has an output schema and rich annotations, the description covers intent, pricing, routing, and signer boundary. It misses no critical context for a read-only tool. Slight deduction for not mentioning pagination or result structure, but 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 coverage is 100%, so baseline is 3. The description does not add meaning beyond the schema; it repeats context about parameters like 'user' but no new semantic 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 'Get all DCA orders (active and optionally historical) for a wallet.' It uses a specific verb ('Get') and resource ('all DCA orders'), and distinguishes from siblings like jupiter_createDCA and jupiter_cancelDCA.

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: 'Use them for quote, route, and swap preparation, then use SAP transaction preview/sign/submit tools.' It also specifies the intent ('read/discovery workflow'), pricing ('paid read-premium; estimate first'), and routing. This clearly tells when to use this tool vs. alternatives.

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