Resistance Tools

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, reducing the burden on the description. The description adds helpful context by specifying the content domains (auth flows, scopes, safety controls, retention, confirmation rules) and that the information is public, which is not covered by annotations.

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

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

The description is a single, front-loaded sentence that quickly communicates the tool's purpose. It lists key content categories without any redundant words or filler.

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

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

For a zero-parameter tool with no output schema, the description provides sufficient detail about what is returned. It could mention the return format, but the listed content categories give the agent a clear expectation for an informational policy 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 tool has zero parameters, so the baseline of 4 applies. The description does not need to explain parameter semantics, and it appropriately focuses on the returned content instead.

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 'Return public MCP auth flows, scopes, safety controls, retention, and confirmation rules.' The verb 'Return' specifies the action, and the resource is explicitly named as public MCP auth and safety policy. This distinguishes it from sibling tools like auth.status.

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

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

The description implies usage by listing the exact content the tool returns, making it clear this is the go-to for auth/safety policy details. However, it does not explicitly mention when not to use it or compare with alternatives, though no close alternatives exist.

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, covering the safety profile. The description adds the scope constraint 'this MCP session' and the exact return semantics (whether authenticated), but it does not elaborate on response formats or potential errors, so it adds modest value beyond annotations.

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

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

The description is a single, concise sentence that front-loads the purpose with zero wasted words.

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

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

The description adequately explains the tool's behavior for a zero-parameter read-only status check. It indicates the return value is a boolean ('whether'), but does not specify the response structure, which would be useful since there is no 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?

The tool has zero parameters, so the schema is fully covered and the description does not need to compensate. The baseline for zero-parameter tools is 4.

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 'Return whether this MCP session is authenticated' clearly states the tool's function with a specific verb and resource. It distinguishes from sibling auth.policy by focusing on authentication status rather than policy.

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 tool is a simple zero-parameter status check, so there are no alternatives to compare. The description implies usage through its clear purpose, though it does not explicitly state when not to use it or reference 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 declare readOnlyHint=true and destructiveHint=false, so the safety profile is clear. The description adds the qualifier 'retained' and the scope 'across the owner's sites,' but does not explain what 'retained' means or any limitations (e.g., pagination). This is modest additional 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 a single, concise sentence that front-loads the action and scope, with no wasted words.

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

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

Given the simple read-only nature and zero parameters, the description adequately conveys the tool's purpose. However, it leaves 'retained' undefined and does not describe the output format (no output schema), so it is slightly under-specified for a standalone 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?

With zero parameters, the schema is fully self-descriptive. The description adds the semantic scope of the listing (retained deployments), which is helpful context, so a baseline 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 clearly states the tool lists retained deployments across the owner's sites, using a specific verb and resource that distinguishes it from sibling tools like sites.list or domains.list.

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 over alternatives. It does not mention related tools, exclusions, or the difference between 'retained deployments' and other deployment-related tools like sites.list_releases.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds the scope ('public') and output nature ('status and records'), but does not disclose return format, potential errors, or rate limits. No contradiction with annotations.

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

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

A single, front-loaded sentence with a clear verb and resource. No wasted words; the entire description is one sentence that earns its place.

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

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

For a simple single-parameter, read-only tool without an output schema, the description adequately captures the core purpose and parameter meaning. It doesn't detail response structure or edge cases, but the low complexity makes this acceptable. Could be improved by specifying what 'status' or 'records' contain.

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

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

The schema provides only 'name' with minLength 1 and 0% description coverage. The description's reference to '.ton name' adds minimal semantic value, but lacks details like whether to include the '.ton' suffix or how to handle non-existent 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 description uses the specific verb 'Lookup' combined with a clear resource 'public TON DNS status and records for a .ton name.' It distinguishes itself from sibling send_*_tx tools by emphasizing read-only public 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 context is clear: this is a read-only lookup for public DNS data. Although no alternatives are explicitly named, the sibling dns.send_*_tx tools are obviously transactional, making the usage intent evident. Lacks explicit 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 indicate readOnlyHint=false, idempotentHint=false, and destructiveHint=false, so the agent knows this may have side effects and is not idempotent. The description adds that it returns a page for a 'validated' transaction, but it does not disclose what side effects occur (e.g., creating a transaction) or any authentication/rate-limit context. With annotations present, the description adds some value but not extensive behavioral 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 a single, front-loaded sentence with zero wasted words. It states the verb, resource, and scope efficiently, earning its place without filler.

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

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

For a tool with only 2 parameters and no output schema, the description covers the action types and the validated nature of the transaction. However, it leaves gaps: it does not explain what the returned HTTPS page contains, how to consume it, whether domain needs '.ton' suffix, or what prerequisites exist. It is minimally adequate but lacks important 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 0%, so the description must compensate for parameter documentation. It only hints at the 'action' values (mint, auction bid, release) and entirely omits the 'domain' parameter. It does not explain domain format, validation rules, or default/toggle behavior, leaving the agent to infer too much from the schema alone.

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

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

The description uses a specific verb 'Return' and identifies a clear resource: 'one HTTPS page for a validated .ton mint, auction bid, or expired-name release transaction.' It distinguishes from sibling DNS transaction tools by enumerating the exact action types (mint, bid, release), making it clear this is for name-related confirmation pages rather than record or renew transactions.

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

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

The description clearly implies when to use the tool—when you have a validated .ton mint, auction bid, or expired-name release transaction. However, it does not explicitly state when not to use it or name alternative tools, though sibling names like dns.send_record_tx and dns.send_renew_tx hint at alternatives. This is clear context but lacks explicit exclusions.

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

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

The description adds valuable behavioral context beyond the annotations: it states that ownership is revalidated live and that the tool returns a user-facing confirmation page rather than directly sending the transaction. This clarifies the interactive flow and complements the readOnlyHint=false and destructiveHint=false 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?

The description is a single, tightly worded sentence that communicates purpose and a key behavioral trait without redundancy or filler. It is well-structured and easy to parse.

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

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

Given the tool has 6 parameters, no output schema, and annotations that don't explain the transaction flow, this description is too sparse for reliable invocation. It omits parameter semantics, return value details, and usage guidance, leaving significant gaps for an agent.

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

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

Schema description coverage is 0%, and the description does not explain any of the 6 parameters (domain, kind, value, keyName, valueKind, rawCategory). It only references 'the exact TON DNS record transaction' without detailing parameter roles, formats, or constraints.

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

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

The description clearly states the tool's function: revalidate live ownership and return a confirmation page for a TON DNS record transaction. It also distinguishes itself from sibling tools like dns.send_name_tx and dns.send_renew_tx by focusing on 'record' transactions.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as dns.send_name_tx or dns.send_renew_tx. It does not mention any exclusions or preferred contexts, leaving the agent without comparative selection criteria.

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

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

Beyond annotations indicating a non-read-only, non-idempotent operation, the description adds that the tool returns an HTTPS page and involves a TON Connect multi-message confirmation, which clarifies the user interaction model. It does not detail prerequisites like ownership verification but mentions 'owned' names.

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

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

The description is a single efficient sentence that front-loads the main verb and packs in all essential details without ambiguity.

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

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

For a tool with one parameter and no output schema, the description adequately covers the function and output. It could mention the next step after obtaining the link, but the 'confirmation' part implies the flow. Given the annotations cover safety, this is sufficiently 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?

Schema description coverage is 0%, so the description must compensate. The description states 'one to four owned .ton names', which explains the domains parameter's purpose and bounds. However, it does not specify the string format (e.g., with or without .ton suffix).

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

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

The description clearly states the action ('Revalidate'), the resource ('owned .ton names'), and the output ('one HTTPS page for a single TON Connect multi-message confirmation'). This distinguishes it from sibling DNS tools like dns.lookup and dns.send_name_tx.

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

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

The description implies usage for renewing .ton names but does not explicitly mention alternatives or when not to use it. No comparison with sibling transaction tools is provided, so the agent must infer from the tool name.

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

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

Annotations already provide readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds the authorization context ('authorized wallet') and the specific domain scope (.ton), but does not elaborate on return format or pagination. This adds some value beyond annotations but lacks rich behavioral 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 a single, concise sentence that directly and efficiently conveys the tool's purpose. Every word earns its place with no redundancy or irrelevant detail.

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

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

For a simple, parameterless, read-only list tool with comprehensive annotations, the description is complete enough. It tells the agent what the tool does (lists .ton domains) and under what scope (owned by authorized wallet), without needing to explain return values beyond the implied 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?

The tool has zero parameters, and the schema is empty with 100% coverage. The description contributes nothing about parameters (there are none), and the baseline for 0 params is 4, as there is nothing to explain.

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

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

The description clearly states the tool lists .ton domains owned by the authorized wallet, using a specific verb and resource. It distinguishes from sibling tools like domains.records, which deals with DNS records for a domain, and dns.lookup, by emphasizing ownership.

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 the tool: to list domains owned by the current wallet. While it doesn't explicitly mention alternatives or exclusions, the 'owned by the authorized wallet' scope provides sufficient usage context, distinguishing it from related 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=true, openWorldHint=true, idempotentHint=true, destructiveHint=false, covering the safety profile. The description adds the ownership requirement, which is a behavioral constraint, but does not disclose return format, errors, or what counts as 'owned'. With annotations carrying the safety burden, this is adequate but not rich.

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

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

The description is a single, front-loaded sentence that states exactly what the tool does. There is no wasted wording or redundant repetition of the title, making it 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?

For a read-only tool with one parameter and strong annotations, the description is minimal but workable. However, without an output schema and with no mention of return values, errors for unauthorized domains, or the structure of 'records', the agent may not fully know what to expect. The simplicity helps, but the description leaves 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 0%, with only minLength on the 'domain' property. The description mentions '.ton domain' but does not specify whether the parameter should include the TLD, case sensitivity, or other formatting details. The parameter semantics are largely left to the agent's inference, failing to compensate for the low 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 uses a specific verb ('Read') and resource ('DNS records for an owned .ton domain'), clearly distinguishing it from sibling tools like dns.lookup (likely generic) and domains.list (lists domains). It provides a precise scope with the ownership qualifier.

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

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

The phrase 'for an owned .ton domain' clearly signals when to use this tool (you must own the domain). It implies differences from dns.lookup, though it does not explicitly name alternatives or exclusions. Context is clear; only an explicit 'use instead' is missing.

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

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

Annotations already declare read-only, idempotent, and non-destructive behavior. The description adds valuable context beyond annotations by noting that sessions are 'redacted' and that data is scoped to the 'authenticated owner wallet', which highlights privacy and authorization boundaries.

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

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

The description is a single, concise sentence that is front-loaded with the action ('List') and immediately states the subject and scope. Every word adds value with no redundancy or filler.

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

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

Given the tool's simplicity (no params, no output schema), the description covers the essential aspects: what is listed, the privacy redaction, and the owner scope. It lacks details about return format or pagination, but for a read-only list tool with strong annotations, this is nearly complete.

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

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

The input schema has zero parameters, and schema description coverage is 100% (trivially). With no parameters to document, the description need not add parameter details. The baseline of 4 for zero-parameter tools applies here.

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

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

The description uses a specific verb ('List') and identifies the exact resources ('MCP consents and redacted active sessions') plus the scope ('authenticated owner wallet'). This clearly differentiates it from siblings like mcp.access.revoke_consent and mcp.audit.list.

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

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

The description implies usage context by naming consents and active sessions, suggesting it is for reviewing current access before revocation. However, it does not explicitly state when to use this tool versus mcp.access.revoke_consent or other list tools, and no exclusions or alternative recommendations are provided.

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

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

Annotations already mark this as destructive, but the description adds valuable context by stating that matching access/refresh tokens are invalidated. This goes beyond the annotation and helps the agent understand the broader impact. It does not, however, discuss irreversibility or failure behavior.

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

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

The description is a single, front-loaded sentence with no filler or redundancy. Every word contributes meaning.

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, but the missing explanation of confirmConsentId and lack of any success/failure expectations create a noticeable gap. The annotations cover the safety profile, but the description itself is not fully self-sufficient for a tool with two required parameters.

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 0%, and the description only alludes to consentId via 'by id'. The confirmConsentId parameter is completely unexplained, likely serving as a confirmation mechanism, but the agent must guess its purpose. This is a significant gap given the tool requires two IDs.

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 a specific verb ('Revoke'), a resource ('MCP consent'), and a clear scope ('by id'), while also noting the consequence of invalidating tokens. This distinguishes it clearly from sibling tools like mcp.access.list, which only lists consents.

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

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

The context implies this tool is for revoking a specific consent, and there are no close alternative tools among siblings (e.g., mcp.access.list is for listing). However, it does not explicitly mention when not to use this tool or reference alternatives, so it stops short of a 5.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the agent knows it is a safe read operation. The description adds context about scoping (owner wallet) and redaction, but does not explain what 'recent' means, whether there is pagination, or what fields are redacted. This is useful but not rich.

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

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

The description is a single, efficient sentence that front-loads the core purpose. Every word adds context: 'List', 'recent', 'redacted', 'MCP audit events', 'authenticated owner wallet'. No filler or redundancy.

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

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

With no output schema, the description does not describe the return format or clarify vague terms like 'recent' or 'redacted'. However, the tool is relatively simple, annotations cover the safety profile, and the basic purpose is clear. Adequate but with gaps in filtering semantics and response structure.

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

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

Schema description coverage is 0%, and the description does not mention any of the four parameters (limit, since, method, resultStatus). The names are somewhat self-explanatory, but the description adds no meaning beyond the schema, failing to compensate for the lack of property 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 uses a specific verb ('List'), identifies the resource ('MCP audit events'), and adds scope ('recent', 'redacted', 'authenticated owner wallet'). This clearly differentiates it from siblings like mcp.audit.summary (which likely summarizes) and mcp.access.list (which lists access events).

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 about when to use this tool versus alternatives such as mcp.audit.summary or mcp.access.list. The description implies usage for retrieving audit events but does not state any conditions, prerequisites, or exclusions.

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

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

Annotations already declare read-only, idempotent, and non-destructive behavior. The description adds valuable context beyond annotations by specifying owner-scoping and excluding raw headers/request bodies, which are meaningful privacy and scope details.

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

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

The description is a single, well-structured sentence that front-loads the action and outcome. Every word earns its place with no fluff or repetition, making it highly 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 tool is simple with two optional parameters and no output schema. The description explains the purpose and key constraints, but it does not describe what metrics are returned or the overall response structure, leaving some gap in completeness for an agent without prior assumptions.

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 0% description coverage, and the description does not mention the parameters or their semantics. While names like windowHours and topMethodsLimit are suggestive, the description does not compensate for the lack of schema descriptions, leaving ambiguity about their exact meaning and usage.

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

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

The description uses a specific verb ('Return') and clearly identifies the resource ('owner-scoped aggregate MCP audit metrics'). It explicitly distinguishes from sibling tools by stating it excludes raw headers and request bodies, contrasting with mcp.audit.list.

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

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

The description clearly implies when to use this tool: when aggregate metrics are needed rather than raw audit events. The contrast 'without raw headers or request bodies' and the sibling name mcp.audit.list provide strong context, though no explicit alternative is named.

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?

No annotations are contradicted. The description adds context by specifying allowed image formats and the owner's store, but it does not disclose behavior like file size limits (already in schema), return values, or overwrite semantics. The annotations already indicate a mutating operation, so the description's added value is modest.

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

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

The description is a single sentence, front-loading the action and target. It contains no filler and every word adds value.

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

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

For a simple one-parameter upload with no output schema, the description covers purpose, permitted formats, and destination. It could mention the return value or authorization requirement, but the annotation and schema provide some context. Overall, it is reasonably 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?

Schema description coverage is 0%, so the description must compensate. It does by naming accepted image formats (PNG, JPEG, GIF, WebP), which adds meaning to the single contentBase64 parameter. However, it does not explicitly explain that the parameter must be Base64-encoded, though the name implies it.

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

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

The description clearly states 'Upload one PNG, JPEG, GIF, or WebP image to the authenticated owner's template media store.' It specifies the verb (Upload), the resource (image), and the target (template media store), distinguishing it from sibling tools like storage.create_bag or sites.publish_files.

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?

There is no explicit when-to-use guidance or mention of alternatives. The description implies a use case (uploading images for templates) but does not state when to prefer this over similar tools like sites.publish_files. Clear context is present, but exclusions are missing.

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 reveals a non-obvious behavior: despite the 'send_tx' name, it does not immediately broadcast a transaction but creates an invoice and returns a page for user review and confirmation. This adds valuable context beyond the annotations, which only indicate a write operation with open world 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 is a single, well-structured sentence that is front-loaded with the core action and includes the key outcome (HTTPS page). It is concise without sacrificing 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?

The description covers the main purpose and flow, but lacks explanation of the 'action' parameter and does not mention any prerequisites or consequences after user confirmation. The lack of an output schema is not an issue, but the unexplained parameter is a notable omission for a tool with only one parameter.

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

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

The single parameter 'action' has an enum (deploy, publish, media) but the description provides no meaning or guidance on how to choose among these values. With 0% schema coverage and no parameter explanation, the agent is left to guess what each action represents, which is a significant gap.

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

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

The description clearly states the tool's function: create a backend-owned payment invoice and return a confirmation page. It uses a specific verb ('create') and resource ('payment invoice'), and distinguishes itself by describing the interactive TON Connect confirmation flow, which is unique among sibling transaction 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 implies when to use it (when needing to create a payment confirmation link) but does not provide explicit when-to-use vs alternatives or any exclusion criteria. Given there are no other payment tools in siblings, the lack of alternative guidance is partially mitigated, but it could still clarify prerequisites like whether a product must exist.

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 the destructiveHint annotation by specifying that both the deployment and served files are deleted, and that only owned sites can be deleted. This is useful for the agent to understand the scope and ownership requirement.

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

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

The description is a single 9-word sentence that efficiently states the action and object with no unnecessary words. Every word earns its place.

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

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

While the description states the basic action, it omits critical operational details such as the purpose of confirmSite, potential irreversibility beyond the annotation, and any side effects hinted by openWorldHint. For a destructive tool, this is a significant gap.

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

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

The schema provides no descriptions for the two required parameters, and the tool description does not explain 'site' or 'confirmSite.' The confirmSite parameter is crucial for confirmation semantics but is completely undocumented, so the description fails to compensate for the 0% schema coverage.

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

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

The description clearly states the tool deletes an owned TON Site deployment and served files, using a specific verb and resource. It distinguishes from siblings like sites.rollback and sites.publish_files by indicating deletion of the deployment and files.

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

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

The description does not explicitly mention when to use this tool vs alternatives like rollback, but it implies usage through the verb 'delete' and the 'owned' precondition. No direct exclusions or alternative tool names are provided.

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

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

Annotations already establish read-only, idempotent, non-destructive behavior. The description adds a small constraint (owned site) and clarifies the data is template/content metadata, but doesn't disclose return format or error 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?

One sentence, nine words, front-loaded with the key action. No fluff or repetition.

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

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

For a simple read operation with one parameter and annotations covering safety, the description is adequate but lacks context about the returned metadata structure and edge cases, especially with no 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?

Schema has 0% coverage, but description compensates partially by noting the site must be owned. The single 'site' parameter's meaning is not detailed beyond that, leaving ID/name ambiguity.

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

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

Clearly states the tool reads stored template/content metadata for an owned site, using an explicit verb (Read) and resource. It doesn't explicitly differentiate from sibling site tools but is specific enough to distinguish from list or mutation operations.

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

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

Implies usage for owned sites but provides no explicit when-to-use guidance or alternatives. There is no mention of when to use this versus sites.list_releases or sites.publish_template.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, establishing the safety profile. The description adds useful ownership scope (authorized wallet), but does not disclose pagination, limits, or return structure. This is adequate given the strong annotations but not exceptional.

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

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

The description is a single concise sentence with no filler or repetition. It front-loads the verb and resource, making it an efficiently structured definition.

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

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

For a zero-parameter, read-only list tool with strong annotations, the description is sufficiently complete. It identifies the resource, the operation, and the ownership scope. No output schema exists, but the tool name and description reasonably imply a list of TON sites.

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 coverage is 100%, so there is no parameter detail to add. The description does not need to explain parameter syntax, and the baseline for 0 params is 4.

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

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

The description uses a specific verb 'List' and resource 'TON Sites' with a clear scope: 'owned by the authorized wallet.' This distinguishes it from sibling tools like sites.get_content and sites.list_releases, making the purpose unambiguous.

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

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

The description implies a query context (listing owned sites) but does not explicitly state when to use this tool versus alternatives like sites.list_releases or sites.get_content. There is no mention of exclusions or alternative scenarios, leaving some ambiguity for an agent deciding among 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 disclose readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description does not need to restate these. It adds the 'retained releases' scope and 'owned site' constraint, but it does not explain what 'retained' means or whether the response is ordered or paginated. The added context is modest but not contradictory.

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

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

The description is a single, front-loaded sentence with no waste. It starts with the verb, names the resource, and includes the ownership constraint efficiently.

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

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

For a simple, read-only, list operation with one parameter and no output schema, the description is largely sufficient. It covers the core purpose and constraint, but it could be more complete by clarifying what 'retained' means or how the output is structured. Given the tool's low complexity, a score of 4 is appropriate.

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 0%, so the description must add meaning to the 'site' parameter. It does state that the site must be owned, which is a useful semantic constraint beyond the schema's type/minLength. However, it does not specify whether the parameter is an ID, name, or other identifier, nor does it describe allowed values or format.

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

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

The description uses the specific verb 'List' and a clear resource ('retained releases for an owned site'), which distinguishes it from sibling tools like sites.list (sites) and sites.get_content (content). It is concise 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?

No guidance is provided on when to use this tool versus alternatives. It does not mention any exclusions, prerequisites beyond ownership, or refer to sibling tools like sites.list for site enumeration. The description simply states the operation without contextual usage advice.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false. The description adds the ownership requirement ('owned TON Site') and the input method ('explicit file contents'), but doesn't detail the destructive behavior (e.g., overwriting existing files) or side effects. It doesn't contradict annotations, but adds limited context.

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

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

The description is a single, front-loaded sentence that efficiently communicates the core action and scope. Every word carries meaning, with no filler or redundancy.

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

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

For a deployment tool with destructive and open-world hints, the description is minimal. It doesn't explain what happens to existing files, whether files are merged or replaced, or what the response looks like (no output schema). The description relies heavily on annotations and schema, leaving important usage gaps.

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

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

Schema description coverage is 0%. The description does not explain the parameters 'site' or 'files', nor the file object structure (path, text, contentBase64). The phrase 'explicit file contents' only hints at 'files' without providing any semantic detail, leaving the agent without guidance on how to construct valid inputs.

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

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

The description clearly states the action ('Deploy or update'), resource ('owned TON Site'), and input source ('explicit file contents'). This distinguishes it from sibling tools like sites.publish_template, which deploys from a template, and sites.delete.

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

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

The phrase 'from explicit file contents' provides clear context for when to use this tool (when you have raw file contents), and 'owned' suggests a prerequisite. However, no explicit alternatives or when-not-to-use guidance is given, so it stops short of a 5.

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

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

The annotations already indicate destructiveHint: true, readOnlyHint: false, and idempotentHint: false, so the agent knows this is a mutating, potentially destructive operation. However, the description adds no additional context about side effects, such as whether it overwrites existing content, incurs costs, or requires specific authorization. It merely lists verbs without behavioral nuance.

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

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

The description is concise and front-loaded, using a single sentence. However, it is under-specified and lacks critical details, so while it is not verbose, it is not 'appropriately sized' in terms of information density.

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 (publishing a site with validation and rendering), the one-line description is insufficient. There is no output schema, annotations are sparse, and the description does not explain the workflow, requirements, or consequences. This is far from complete for a publish 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?

Schema description coverage is 0% and the description does not mention any of the three parameters (site, content, template). There is no explanation of what 'content' should contain, what 'template' refers to, or how they interact. The description fails to compensate for the schema's lack of documentation.

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

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

The description states a clear action (validate, render, publish) and resource (template-based TON Site). 'Template-based' distinguishes it from the sibling tool 'sites.publish_files', which likely handles file-based publishing. However, it does not explicitly differentiate itself from all 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?

There is no guidance on when to use this tool versus alternatives like 'sites.publish_files' or when a template-based approach is appropriate. The description simply states the action without contextualizing it against other publishing or site management 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 destructiveHint=true and readOnlyHint=false, so the description is not required to restate these. It adds context by specifying 'owned' and 'retained release', but does not disclose the confirmation mechanism or what happens to the site during rollback.

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

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

The description is a single, front-loaded sentence with no wasted words. It focuses on the core purpose without unnecessary elaboration.

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

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

This is a destructive operation with 3 required parameters and no output schema. The description omits prerequisites, the role of confirmSite, and what the expected outcome or return value is. Annotations provide some context but do not fill all 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 schema description coverage at 0%, the description must compensate. It only vaguely alludes to 'releaseId' via 'retained release' and 'site' implicitly, but does not explain the critical 'confirmSite' parameter or its purpose.

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

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

The description clearly states the action ('Rollback'), the resource ('an owned TON Site'), and the target ('to a retained release'). It distinguishes this tool from siblings like sites.delete and sites.publish_files by specifying the rollback to a previous release.

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

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

The description implies the tool is used when you want to revert a site to a previously retained release, but it does not explicitly state when to use it versus alternatives, nor does it mention any prerequisites or exclusions.

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

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

Annotations indicate readOnlyHint=false and openWorldHint=true, which align with the description's mention of 'live ownership' validation and returning a confirmation page. The description adds useful context about the validation step and the exactness of the transaction, going beyond the bare annotations without contradicting them.

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

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

The description is a single, focused sentence that conveys the core action and output without extraneous details. It is appropriately concise and front-loaded, making it easy for an agent to parse quickly.

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

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

The description covers the basic function and return value, but lacks guidance on side effects after confirmation, prerequisites, or how this tool fits relative to the many sibling transaction tools. Without an output schema, more explanatory detail about the returned page and the confirmation flow would improve completeness.

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

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

The schema has one required parameter 'site' with no description (0% coverage), and the tool description does not explain what 'site' should contain (e.g., a domain name, a site ID, or a URL). The description mentions 'TON DNS site transaction' but does not explicitly map the parameter to that concept, leaving the agent to guess the expected format.

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 live ownership and returns an HTTPS page for confirming an exact TON DNS site transaction. It uses specific verbs ('Validate', 'return') and specifies the resource (TON DNS site transaction), distinguishing it from sibling transaction tools like dns.send_name_tx or storage.send_bag_link_tx.

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

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

The description implies the tool should be used when a TON DNS site transaction needs ownership validation and user confirmation via TON Connect. However, it does not explicitly state when to use this tool versus alternatives like dns.send_name_tx or payments.send_tx, nor does it provide exclusions or prerequisites.

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

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

Annotations already cover the safety profile (readOnlyHint, openWorldHint, idempotentHint, destructiveHint). The description adds the 'owned' constraint and 'live state', giving some additional context, but it does not disclose what metadata or state details are returned, leaving some behavioral ambiguity.

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

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

The description is a single concise sentence, front-loaded with the action, and contains no unnecessary words. Every part contributes meaning.

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 1 param and strong annotations, the description is adequate but leaves gaps. 'Metadata and live state' is vague—there is no output schema, so the description should clarify what data the response contains. The ownership prerequisite is mentioned, but no other edge cases or behavioral details are covered.

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

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

The schema has one param (bagId) with 0% schema description coverage, so the description must compensate. The param name 'bagId' and the phrase 'an owned TON Storage bag' make its purpose reasonably clear, but the description does not explicitly explain the field format or that it identifies the bag. Since the param is self-evident from the tool name, this is adequate but not strong.

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

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

The description uses the specific verb 'Read' with a clear resource ('TON Storage bag') and scope ('owned'), distinguishing this from sibling tools like storage.create_bag, storage.delete_bag, and storage.list_bags. It clearly indicates this is for reading details of a single bag rather than listing or mutating.

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

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

The description implies when to use this tool (to inspect a specific owned bag) and notes an ownership prerequisite. It does not explicitly name alternatives or exclusions, but the context is clear enough given the sibling tool names (e.g., list_bags for listing).

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 this as a non-read-only, open-world operation, and the description adds the 'seed' behavior, indicating initial content upload. However, it does not disclose consequences like duplicate bag handling, funding requirements, or external side effects beyond creation.

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 entire description is a single 12-word sentence that is front-loaded with the action and resource. It contains no redundant information.

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

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

For a create tool with two parameters and no output schema, the description is serviceable but lacks return-value information and any context about the 'name' field. It does not fully cover the behavior necessary for an agent to invoke it confidently, though the schema fills 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 schema has two parameters but the description provides 0% parameter coverage. It only vaguely says 'explicit file contents,' leaving the optional 'name' parameter and the file object structure (text vs. base64) unexplained.

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

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

The description uses a specific verb 'create and seed' with the resource 'TON Storage bag' and source 'explicit file contents,' clearly differentiating it from other storage operations like deleting, listing, or pinning. This directly states what the tool does.

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

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

The description implies the tool is for creating and seeding a bag from file contents, but it offers no explicit guidance on when to choose this over related tools such as pin_bag or publish_files. There is no 'when not to use' or alternative tool mentioned.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the destructive nature is covered. The description adds the conditional secondary behavior of 'remove platform-seeded bytes when safe,' which is extra context beyond the annotations. It does not explain what 'safe' means, but the annotations mitigate the need for a full disclosure.

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

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

The description is a single, efficient sentence that front-loads the primary action ('Delete an owned TON Storage bag reference') and appends the conditional behavior ('and remove platform-seeded bytes when safe'). Every word earns its place with no redundancy.

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

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

For a destructive tool with two required parameters and no output schema, the description provides the core purpose but omits the confirmation semantics of confirmBagId and the definition of 'safe.' This leaves meaningful gaps for correct invocation, making the description minimally viable 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?

Schema description coverage is 0%, and the description does not mention bagId or confirmBagId at all. The parameter names imply their roles (an ID and a confirmation), but the description provides no explicit meaning, especially the critical requirement that confirmBagId matches bagId. The description fails to compensate for the schema's lack of 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 uses the specific verb 'Delete' and identifies the resource as an 'owned TON Storage bag reference,' adding a secondary conditional action of removing 'platform-seeded bytes when safe.' This clearly distinguishes it from sibling tools like create_bag, pin_bag, and list_bags, which have different purposes.

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

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

The phrase 'owned' and 'when safe' imply conditions for use, suggesting the tool is only for bags the user owns and only under certain safety conditions. However, there is no explicit guidance on when to use this tool vs. alternatives, nor are any sibling tools named or excluded, so usage context is only implied.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false, so safety is covered. The description adds the ownership scope, but does not disclose return format, pagination, or other behavioral characteristics. This is sufficient but not extensive.

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

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

A single sentence, precisely worded, with no superfluous information.

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

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

For a simple parameterless list tool with rich annotations, the description is mostly complete. However, it does not specify the returned data structure, which would be helpful if no output schema is available.

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?

There are zero parameters, so the description bears no responsibility for parameter semantics. Baseline 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 uses the specific verb 'List' with the resource 'TON Storage bags' and scope 'owned by the authorized wallet'. This clearly differentiates it from sibling tools like storage.bag_details (single bag details), storage.create_bag, and storage.delete_bag.

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

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

The description clearly indicates when to use the tool: to list all storage bags associated with the authenticated wallet. It does not explicitly mention alternatives or exclusions, so it doesn't reach the highest level, but the context is unambiguous.

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

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

Annotations already indicate this is a write operation (readOnlyHint=false) and non-idempotent. The description adds no behavioral context beyond that, such as side effects of pinning, auth requirements, or return behavior. It does not contradict annotations but contributes no additional 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 a single concise sentence, front-loaded with the action and resource. No unnecessary words.

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

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

No output schema exists, and the description does not explain what the operation returns. It also doesn't clarify how pinning differs from other storage operations or what happens after pinning. The tool is simple but the description leaves key context gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'bag id' corresponding to bagId, but provides no explanation of the optional 'name' parameter. Semantics are incomplete.

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 ('Pin/import') and the resource ('existing public TON Storage bag'), with the method ('by bag id'). It distinguishes from sibling tools like create_bag (new bag) and list_bags (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 context is clear: use for existing public bags, not for new ones. It doesn't explicitly name alternatives, but the phrase 'existing public' implies when not to use (for private/new bags). No exclusions are stated, but the guidance is adequate.

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 this as read-only, idempotent, and non-destructive, so the safety profile is covered. The description adds minor context about operating on a 'live provider session,' which implies a prerequisite, but doesn't elaborate on what happens if the session is invalid or whether the preview consumes resources. It meets the baseline but adds limited behavioral detail 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 a single, compact sentence that starts with the action verb and conveys the essence without fluff. Every word contributes to meaning, making it highly efficient and easy to parse.

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

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

With four required parameters, no output schema, and no schema descriptions, the description is severely inadequate. It does not explain what bagId or sessionId refer to, what targetCoverageSeconds or proofSpanSeconds mean, or what the returned 'exact integer funding and coverage' looks like. The tool is complex, and the description fails to provide the necessary context for correct invocation.

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

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

Schema description coverage is 0%, so the description must explain parameter meanings. It only mentions 'funding and coverage' which vaguely relates to targetCoverageSeconds and proofSpanSeconds but does not explain any of the four required parameters (bagId, sessionId, targetCoverageSeconds, proofSpanSeconds). The agent has no semantic grounding for constructing the call.

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

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

The description uses a specific verb ('Calculate') and identifies the exact resource: 'exact integer funding and coverage from a live provider session.' It clearly distinguishes itself from sibling tools like storage.provider_funding_session (which implies session management) and storage.provider_quote (which suggests a quote), while 'preview' highlights its non-committal nature.

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 no explicit guidance on when to use this tool versus alternatives like storage.provider_quote or storage.provider_funding_session. It implies a prerequisite by saying 'from a live provider session' but fails to explain the workflow or mention any exclusions. This leaves the agent without clear decision criteria.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, covering key safety traits. The description adds that the snapshot is 'short-lived' and requires an owned bag, providing useful context. However, it does not disclose the return value or any operational constraints beyond ownership.

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

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

A single, front-loaded sentence that conveys the core action without filler. Every word contributes to understanding the tool's 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?

The tool is simple (2 params) and annotations cover safety, but the description omits usage guidelines, return information, and explicit parameter semantics. It is minimally viable but leaves gaps for an AI agent to infer, especially around what the session is for and what happens when invoked.

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 0% schema description coverage, the description must compensate for missing parameter meanings. It only implicitly maps 'owned bag' to bagId and 'provider' to providerPubkeys, but it does not explain the exact purpose, format, or relationship between the two parameters. This is insufficient given the absence of 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 uses the specific verb 'Freeze' and identifies a clear resource: 'a short-lived live provider and shared-balance snapshot for an owned bag.' This distinguishes it from sibling tools like provider_funding_preview and provider_quote, which likely serve different purposes. The title 'Create provider funding session' aligns with the description.

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

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

The phrase 'for an owned bag' implies a prerequisite, but the description gives no explicit when-to-use, when-not-to-use, or alternative guidance. Usage is only inferred from the verb and resource, without contrasting with sibling storage 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, and destructiveHint. The description adds the term 'reconcile' and clarifies the operation is 'paid', providing some context beyond annotations. However, it does not explain what 'reconcile' entails or describe return values.

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

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

The description is a single, front-loaded sentence with no redundant information. Every word contributes to conveying the tool's core purpose.

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

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

For a simple read operation with one parameter and strong annotations, the description is sufficient for basic invocation. It could be improved by elaborating on the 'reconcile' behavior or return format, but overall it covers the essential 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?

With 0% schema description coverage, the description must compensate for the missing param info. It does so indirectly by explaining the operation's purpose, implying the providerOperationId is the identifier of the operation to read. Yet it does not explicitly describe the parameter format or origin.

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

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

The description clearly states the action (Read and reconcile) and the resource (one paid TON Storage provider operation). While it doesn't explicitly name sibling alternatives, the specificity of 'one paid TON Storage provider operation' distinguishes it from related tools like storage.providers and storage.provider_quote.

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

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

The description provides no guidance on when to use this tool vs. alternatives. It neither mentions prerequisites nor contrasts with other storage tools, leaving the agent without clear selection criteria.

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

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

Annotations already provide readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, covering safety profile. The description adds useful context about the quote being 'signed' and 'revalidated,' but it doesn't clarify the apparent tension between the verb 'Create' and readOnlyHint, nor does it provide additional behavioral details beyond that.

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 one sentence, front-loaded with the verb 'Create,' and contains no unnecessary words. It is efficiently structured for a short tool description, even though it omits important 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?

For a tool with four required parameters and no output schema, the description is severely incomplete. It explains neither the parameters' roles, the return value, nor the broader workflow beyond the revalidation note. Significant additional detail is needed for an agent to invoke this tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate, but it provides no information about the meaning or use of the four required parameters (bagId, sessionId, targetCoverageSeconds, proofSpanSeconds). The description adds zero value to the schema's bare parameter names and types.

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 'Create' and the resource 'signed backend quote', and adds a distinguishing detail about revalidation before a provider confirmation link is returned. This differentiates it from sibling tools like storage.provider_funding_preview or storage.provider_funding_session.

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

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

The description implies the tool is used when a signed backend quote is needed and that this happens before returning a provider confirmation link. However, it doesn't explicitly mention when to use it versus alternatives or provide exclusions, leaving the guidance implied rather than explicit.

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

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

Annotations already declare read-only, open-world, idempotent, and non-destructive behavior. The description adds that providers are 'backend-verified' and 'compatible with an owned bag', which clarifies filtering criteria and the prerequisite of owning a bag. However, it does not detail response format or sort behavior beyond this.

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

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

Single sentence, front-loaded with the verb, no redundant words. It efficiently conveys the core function.

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

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

The tool is a simple list operation with good annotation coverage. The description provides the essential purpose and context (owned bag, compatibility), though it omits response field details or sort explanation. Overall, it is adequate for a tool of this complexity.

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

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

The schema has two parameters with zero description coverage. The description explains that bagId refers to the owned bag, but does not elaborate on the 'sort' enum values or their semantics. Since the schema is minimal, the description only partially compensates.

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

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

The description uses a specific verb ('List') and resource ('backend-verified providers'), with qualifying scope ('compatible with an owned TON Storage bag'). This clearly distinguishes it from sibling tools like storage.provider_quote or storage.list_bags.

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

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

The description implies usage context (you need an owned bag) but does not explicitly state when to use this tool over alternatives. It doesn't reference sibling tools or mention exclusions, so the agent must infer the use case.

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

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

The description says 'Validate... then return one HTTPS page,' which sounds like a read-only operation, yet annotations set readOnlyHint=false. This suggests the tool may have side effects (e.g., creating a transaction) that are not disclosed. The description does not explain what 'send' entails, whether a wallet is required, or what effects occur beyond returning a page. With annotations already indicating non-read-only behavior, the description adds insufficient context and potentially underplays mutability.

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

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

The description is a single, efficient sentence that clearly front-loads the action ('Validate... then return'). There is no redundant wording or fluff. It earns its place by covering the core purpose without unnecessary detail.

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

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

Despite having only 2 parameters and no output schema, the description is incomplete. It does not explain what the returned HTTPS page represents, how to use it, or what 'exact TON Storage DNS site transaction' means. The readOnlyHint=false suggests additional behavior that the description fails to cover. Given the existence of similar sibling tools, the description leaves significant gaps in understanding the tool's full effect and usage.

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 0%, so the description must compensate for the lack of parameter documentation. It mentions 'bag and domain' which maps to bagId and domain, adding basic context that the tool validates ownership of these. However, it does not clarify the expected format, constraints, or relationship between the parameters. The parameter names are self-explanatory to a degree, but the description adds only minimal value beyond the schema.

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

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

The description states a specific action: 'Validate bag and domain ownership, then return one HTTPS page for the exact TON Storage DNS site transaction.' This clearly identifies the tool's purpose and its scope (storage-backed DNS site transaction). However, it does not explicitly distinguish itself from the sibling tool 'sites.send_link_tx', which may serve a similar purpose for non-storage sites, so it falls short of a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any prerequisites, exclusions, or conditions under which a different tool should be used. The context signals show several related 'send_*_tx' and 'link_tx' tools, but the description offers no differentiation, leaving the agent to infer 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 flag a destructive, non-read-only operation. The description adds valuable context: it revalidates live contract, providers, shared balance, and exact amount, and returns a confirmation page rather than directly executing the transaction. It does not disclose auth needs, rate limits, or what happens after the link is used.

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 entire description is one dense, front-loaded sentence with no filler. Every word contributes to the behavioral contract and action scope, making it efficient and appropriately sized.

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 six parameters, no output schema, and a destructive annotation, the description is too thin. It says the return is a single HTTPS confirmation page and lists pre-checks, but it does not explain how parameters relate to each action, which inputs are prerequisites, or the behavior of the confirmation flow.

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 0%, so the description must compensate for six parameters, but it only names action types already in the schema and loosely references 'providers', 'shared balance', and 'exact amount' without mapping them to bagId, quoteId, providerPubkey, targetCoverageSeconds, or acknowledgeOtherProviders.

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

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

The description uses a specific verb ('Revalidate ... before returning') and identifies the resource: a paid Storage provider confirmation link for pin, top-up, stop, or withdraw. This clearly differentiates it from sibling tools like storage.pin_bag or storage.provider_operation.

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

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

The description implies the tool is used to create a confirmation link after revalidating contract state, but it provides no explicit guidance on when to choose this tool over siblings like storage.provider_quote or storage.send_bag_link_tx, nor any 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 already indicate destructive (destructiveHint=true) and non-idempotent behavior. The description adds that it revalidates rights and returns a confirmation page, which is useful context beyond the annotations. However, it does not disclose what the 'management transaction' will actually do (e.g., withdraw fees, transfer admin) or any side effects. It adds some value but leaves significant gaps.

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

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

The description is a single sentence, which is concise in length. However, the phrasing 'Revalidate current collection or parent rights' is awkward and unclear, and the sentence does not provide enough substance to be considered well-structured or informative. It is short but not effectively so.

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 8 parameters, no output schema, and several sibling tools, the description is insufficient for an agent to fully understand the tool's behavior. It does not explain what the confirmation page contains, what happens after validation, or how the action parameter changes the transaction. The lack of details about return values and side effects makes it incomplete for safe invocation.

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

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

Schema description coverage is 0%, so the description must compensate for undefined parameters. It does not mention any parameter names (e.g., collectionAddress, action, wallet) nor explain how the enum values like 'withdraw_fees' or 'transfer_admin' relate to the action. This leaves the agent entirely dependent on the schema's limited fields and enums.

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 a specific verb ('Revalidate') and resource ('current collection or parent rights'), and mentions the output ('HTTPS management transaction confirmation page'). However, it is unclear what 'revalidate' means in this context and how it relates to the tool's name 'collection_action_tx'. It does not clearly distinguish this from other subdomain transaction tools like subdomains.mint_tx or subdomains.transfer_item_tx.

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. The phrase 'Revalidate current collection or parent rights' implies a prerequisite validation step, but it does not explain which actions require this tool or when other tools (e.g., subdomains.create_collection_tx) would be more appropriate. No alternatives are mentioned.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered. The description adds the behavioral details that the state is 'fresh' and scoped to the authenticated wallet, which is useful context. However, it does not disclose potential errors or response format, so it only slightly exceeds the annotation baseline.

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

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

The description is a single sentence, front-loaded with the verb, and contains no filler. Every word adds meaning, making it highly concise and well-structured.

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

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

With no output schema and one parameter lacking explanation, the description omits important context: it does not describe what the response contains or how the parameter affects the call. For a read tool, return-value details are essential, and the parameter semantics are missing, leaving the definition incomplete.

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

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

Schema description coverage is 0%, and the description does not mention the 'collectionAddress' parameter at all. The agent must infer its meaning from the name alone, which is not enough to use the tool confidently.

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 reads specific control state (collection authorization and parent-return state) for the authenticated wallet, using a specific verb and resource. It distinguishes itself from sibling tools like subdomains.get_collection by focusing on control state rather than general collection 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 gives no guidance on when to use this tool versus alternatives or any prerequisites. It does not mention scenarios, exclusions, or related tools, leaving usage entirely to inference.

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

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

Annotations already convey readOnlyHint=false and idempotentHint=false, indicating a mutating, non-idempotent operation. The description adds useful context about the process (ownership validation, metadata creation) and the output (confirmation page). However, it does not disclose potential side effects or what happens after confirmation, providing moderate 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 a single sentence with no filler, front-loading the core purpose and steps. It is efficient and clear.

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 4 required parameters, no output schema, and zero parameter descriptions, the description is too sparse. It provides a high-level overview but omits parameter meanings, error handling, the transaction flow, and what the confirmation page entails, making it incomplete for practical use.

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 0%, so the description must compensate. It only indirectly references parentAddress via 'parent ownership'; mode, priceGrid, and minChars are not explained. The enum values and array semantics remain undocumented, leaving significant gaps.

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

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

The description clearly identifies the tool as creating a subdomain collection transaction link, with specific actions: revalidate parent ownership, create collection metadata, and return an HTTPS confirmation page. This is a distinct verb+resource pairing that differentiates it from sibling tools like mint_tx or collection_action_tx.

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

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

The description implies a prerequisite (revalidate parent ownership) but does not explicitly state when to use this tool versus alternatives. There is no mention of exclusions or comparisons with siblings like collection_action_tx or mint_tx, offering limited usage guidance.

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

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

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, so the description adds value by disclosing the authorization requirement and the 'fresh' nature of the snapshot. These details go beyond the structured annotations and do not contradict them.

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

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

The description is a single, well-structured sentence that front-loads the core action and then adds the permission condition. There is no wasted wording, and all content earns its place.

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

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

For a simple read tool with one parameter and strong annotations, the description covers the key prerequisites (permissions) and the behavioral nuance (fresh snapshot). The return value is implied by 'snapshot,' and since no output schema exists, this is acceptable. The auth condition is a meaningful addition.

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 0% schema description coverage, the description should compensate by explaining the parameter, but it does not mention collectionAddress at all. The parameter name is somewhat self-explanatory, but the description adds no additional meaning about its format or usage, leaving the agent to infer from the tool name and domain context.

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

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

The description uses a specific verb ('Read') and resource ('collection snapshot'), clearly indicating the tool's function. It also adds the context of a 'fresh' snapshot, which distinguishes it from cached reads. However, it does not explicitly contrast with sibling tools like list_collections or get_item, though the singular 'collection' implies a single-resource lookup.

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

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

The description states a clear prerequisite: use only when the authenticated wallet holds collection or parent rights. This is useful context but does not advise when to prefer this tool over alternatives or when not to use it. No specific alternative tools are mentioned, so the guidance is implied rather than explicit.

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

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 safety profile is clear. The description adds the ownership requirement, which is useful behavioral context beyond annotations, but does not disclose error behaviors or return formats.

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

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

The description is a single sentence of 12 words, front-loaded with the verb 'Read'. Every word earns its place, with no redundancy or fluff.

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

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

For a simple read tool with strong annotations, the description is mostly adequate. However, the lack of parameter explanation and the absence of any mention of behavior when the item is not owned or not found leave some guidance gaps.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented 'itemAddress' parameter. It fails to do so; the description doesn't mention that itemAddress identifies which subdomain item to read. The parameter name is self-explanatory, but no explicit connection is made.

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

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

The description clearly states the action ('Read'), the resource ('Subdomain NFT item'), and the scope ('owned by the authenticated wallet'). This distinguishes it from write operations like subdomains.mint_tx and from list operations like subdomains.list_items, though it does not explicitly name alternatives.

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

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

The description implies usage for reading a single owned subdomain item, and the ownership constraint is a helpful usage hint. However, it does not provide explicit when-to-use guidance or mention alternatives such as subdomains.list_items for listing all owned items.

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 the important scoping detail that results are limited to collections controlled by the authenticated wallet, complementing the annotations (readOnlyHint, openWorldHint, idempotentHint, destructiveHint). It does not contradict annotations and provides meaningful behavioral context beyond the structured hints.

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

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

The description is a single, front-loaded sentence that states the action, resource, and scope with zero wasted words. It is perfectly appropriate in length.

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

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

For a simple list endpoint with optional pagination parameters and no output schema, the description covers the essential scope and action. It could have mentioned pagination behavior, but the schema plus annotations provide adequate context for this low-complexity tool.

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

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

Schema description coverage is 0%, and the description does not mention pagination or the semantics of 'limit' and 'cursor'. Although the parameter names are conventional, the description fails to clarify that these are pagination controls, leaving the agent to infer their use from the schema alone.

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

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

The description uses a specific verb ('List') and a specific resource ('TON Subdomain collections controlled by the authenticated wallet'), clearly distinguishing it from siblings like subdomains.get_collection (single item) and subdomains.list_items (items within collections).

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: it lists collections owned by the authenticated wallet, implying a read-only, scoped operation. It does not explicitly mention alternatives or exclusions, but the scope and sibling names make the intended usage unambiguous.

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

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

Annotations already declare this as a safe read operation (readOnlyHint=true, destructiveHint=false). The description adds ownership filtering context beyond the annotations, but it does not mention pagination behavior or return format. Given the strong annotation coverage, this is acceptable.

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

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

The description is a single sentence with no wasted words. It is front-loaded with the verb and resource, making it easy to scan.

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

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

For a simple read-only list tool with rich annotations, the description is mostly complete. It clearly identifies the resource and scope, but it omits pagination details (limits, cursor) that would be useful given the lack of output schema. Still, it covers the essential purpose.

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 0% schema description coverage, the description should compensate by explaining limit and cursor parameters. It does not mention pagination at all, leaving parameter semantics under-explained. The parameter names are self-explanatory, but the description adds no value beyond the schema constraints.

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

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

The description clearly states the tool lists TON Subdomain NFT items owned by the authenticated wallet. It uses a specific verb (list), resource (subdomain NFT items), and scope (owned by authenticated wallet), which distinguishes it from siblings like subdomains.list_collections and subdomains.get_item.

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 by specifying 'owned by the authenticated wallet,' which implies when to use it. However, it does not explicitly mention when not to use it or name alternative tools, so it lacks explicit exclusions.

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

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

Annotations already indicate a non-read-only, non-idempotent operation. The description adds context by mentioning revalidation of availability/access and returning a confirmation page, implying a multi-step process and a URL output. However, it does not disclose side effects, potential failure modes, or whether a transaction is actually submitted or just a link is generated.

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

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

The description is a single sentence that is front-loaded with the core process steps (revalidate, build metadata, return page). It avoids unnecessary words, though the phrase 'mint or pending-mint' is slightly redundant. Overall, it's concise and well-structured for the content it provides.

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 four parameters with no descriptions, no output schema, and a non-trivial operation (minting). The description only offers a high-level overview and doesn't explain what the confirmation page contains, how parameters relate to the operation, or what side effects occur. This is insufficient for an agent to invoke it correctly without additional inference.

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 zero descriptions for its four parameters (label, parent, collectionAddress, setWalletToMinter), and the description provides no explanation of any of them. With 0% schema coverage, the description should compensate but completely fails to define the meaning or format 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 identifies a specific action: revalidate availability/access, build metadata, and return a confirmation page. The resource is clearly the subdomain mint confirmation link, and the tool name/title reinforce this. It doesn't explicitly distinguish from sibling subdomain tools like transfer_item_tx or recovery_tx, but the mint-specific wording makes the purpose clear.

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

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

No guidance is given on when to use this tool versus alternatives. There is no mention of prerequisites, exclusions, or relationship to sibling tools such as subdomains.transfer_item_tx or subdomains.recovery_tx. The description only states what it does, not when or why to choose it.

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

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

Annotations already indicate readOnlyHint=false and destructiveHint=false. The description adds that it returns one HTTPS page for a recovery transaction, but does not clarify whether the tool itself performs an on-chain transaction or just generates a link. This ambiguity about side effects is not resolved 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 a single, focused sentence that directly names the action and outcome. It is efficiently front-loaded and contains no filler or redundant 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 tool has no output schema and three required parameters with zero description coverage. While the description mentions 'owned collection' and 'recovery transaction', it omits crucial context like how ownership is validated, what the returned page is used for, any error conditions, or how parameters map to behavior. The description is too sparse for a transaction-related 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?

With 0% schema description coverage, the description should explain parameter meanings, but it only vaguely references 'deployment or resolver recovery', which loosely maps to the action enum. It fails to define 'parentAddress', the 'mode' enum (locked/linked), or the specific actions (retry_deployment, link_resolver, enforce_resolver), leaving the agent to guess.

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 re-derives an owned collection and returns an HTTPS page for deployment or resolver recovery, which is a specific action not fully covered by sibling tools. The verb 're-derive' and resource 'recovery transaction' give it a distinct purpose, though it doesn't explicitly contrast with sibling tools like 'collection_action_tx'.

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

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

The description implies usage for recovering deployment or resolver transactions on an owned collection, but does not explicitly state when to use this tool over siblings or what prerequisites exist. No exclusions or alternative recommendations are provided, leaving the agent to infer the intended 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, readOnlyHint=false, openWorldHint=true, idempotentHint=false. The description adds the 'revalidate ownership' behavioral step and the output of an HTTPS confirmation page, but does not elaborate on side effects or confirmation link validity. It provides some value 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 a single concise sentence that front-loads the core action and output. There is no redundant content or unnecessary detail.

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

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

With no output schema and 0% parameter description coverage, the description must carry full contextual burden. It explains the overall action and return type, but lacks parameter semantics, usage conditions, and any potential side effects, making it incomplete for a transactional/destructive 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 schema has two required parameters (itemAddress, newOwner) with no descriptions, and schema description coverage is 0%. The description does not mention these parameters at all, leaving the agent to infer their meanings from the tool name. This is insufficient for reliable invocation.

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

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

The description clearly states the action ('Revalidate current NFT ownership and return') and resource ('Subdomain item transfer confirmation page'). The title reinforces the purpose. It distinguishes from sibling tools like subdomains.mint_tx and subdomains.recovery_tx by specifying 'transfer item'.

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. There is no mention of scenarios, prerequisites, or contrast with other subdomain transaction tools. The description only states what it does without context for selection.

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

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

The annotations already declare readOnly, idempotent, and non-destructive behavior. The description adds value by specifying that the context is for the authenticated owner/actor, highlighting an authentication requirement that is not explicit in the annotations. It does not contradict any annotations.

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

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

The description is a single, concise sentence that front-loads the action ('Return') and directly states the resource. There is no wasted wording, and the structure is optimal for a simple getter 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?

Given the tool's simplicity (no parameters, no output schema) and strong annotations, the description is nearly complete. It clearly states what is returned, though 'wallet context' is slightly vague about the exact contents. Overall, it provides sufficient context for a tool of this complexity.

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

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

The tool has zero parameters, so the schema is trivially complete. Per the rubric, the baseline for 0 parameters is 4, and the description adds no parameter info because there are none to describe. No deduction is needed.

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

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

The description uses a specific verb ('Return') and clearly identifies the resource ('authenticated MCP owner/actor wallet context'). It is unambiguous and distinguishes itself from sibling tools by being the only one that returns wallet 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?

There is no explicit guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. The usage is only implied by the tool's purpose, which is insufficient for a complete usage guideline.

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