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

With no annotations provided, the description carries full burden for behavioral disclosure. It states the action ('approves') which implies a write/mutation operation, but doesn't mention required permissions, whether the action is reversible, potential side effects, or what the response looks like. For a mutation tool with zero annotation coverage, this is insufficient.

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

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

The description is a single, efficient sentence that states the core functionality without unnecessary words. It's appropriately sized and front-loaded with the essential information, 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?

For a mutation tool with no annotations and no output schema, the description is incomplete. It doesn't explain what 'approve' entails operationally, what permissions are needed, what happens to the comment status, or what the tool returns. Given the complexity of modifying content in a CMS, more context is needed.

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

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

Schema description coverage is 100%, so the schema already fully documents both parameters (site and id). The description doesn't add any parameter semantics beyond what's in the schema, such as clarifying what 'approve' means for the comment status or format requirements. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the action ('approves') and the target resource ('a pending comment'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like wp_spam_comment or wp_update_comment, which would require 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 like wp_update_comment or wp_spam_comment. It doesn't mention prerequisites (e.g., that the comment must be in 'pending' status) or contextual constraints, leaving the agent to infer usage from the tool name alone.

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

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

No annotations are provided, so the description carries full burden for behavioral disclosure. While 'Clear cache' implies a destructive/mutative operation, the description doesn't mention important behavioral aspects like whether this requires admin permissions, whether it affects site performance during clearing, what happens to cached data, or potential side effects. It provides minimal context beyond the basic action.

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

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

The description is a single, efficient sentence with zero wasted words. It's appropriately sized for a simple tool and front-loads the essential information immediately.

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 cache-clearing operation with no annotations and no output schema, the description is insufficient. It doesn't explain what 'clearing cache' entails operationally, what gets cleared, potential performance impacts, or what the tool returns. Given the complexity of cache operations and lack of structured documentation, more context is needed.

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

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

Schema description coverage is 100%, so the schema already documents both parameters (site and pattern) with clear descriptions. The description doesn't add any meaningful parameter semantics beyond what's in the schema. The baseline of 3 is appropriate when the schema does the heavy lifting for parameter documentation.

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

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

The description clearly states the action ('Clear cache') and target ('for a WordPress site'), providing a specific verb+resource combination. However, it doesn't distinguish this tool from sibling tools like wp_cache_info or wp_cache_stats, which also relate to cache operations but serve 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 description provides no guidance on when to use this tool versus alternatives. There are several sibling cache-related tools (wp_cache_info, wp_cache_stats, wp_cache_warm), but the description doesn't indicate when clearing cache is appropriate versus checking cache status or warming cache.

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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states this is a read operation ('Get'), which is helpful, but doesn't mention authentication requirements, rate limits, error conditions, or what format the 'detailed information' returns. For a tool with zero annotation coverage, this leaves significant behavioral gaps.

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

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

The description is a single, efficient sentence that gets straight to the point with zero wasted words. It's appropriately sized for a simple read operation and front-loads the essential information 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?

For a single-parameter read tool with good schema coverage but no annotations or output schema, the description is minimally adequate. It states what the tool does but lacks important context about authentication, return format, and differentiation from sibling cache tools. The absence of an output schema means the description should ideally provide more guidance about what information is returned.

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

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

The schema description coverage is 100% with the single 'site' parameter fully documented in the schema. The description adds no additional parameter information beyond what's already in the structured schema, so it meets the baseline expectation without adding extra value.

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

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

The description clearly states the action ('Get') and the resource ('detailed cache configuration and status information'), making the purpose immediately understandable. It doesn't explicitly differentiate from sibling cache tools like wp_cache_stats or wp_cache_clear, but the specificity of 'configuration and status' provides some implicit distinction.

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 like wp_cache_stats or wp_cache_clear. There's no mention of prerequisites, context, or comparative use cases with sibling tools, leaving the agent to infer usage patterns from tool names alone.

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 provided, so the description carries the full burden of behavioral disclosure. It states the tool 'gets' data, implying a read-only operation, but doesn't specify permissions, rate limits, or what happens if the site parameter is omitted (e.g., fails or uses a default). This leaves gaps in understanding the tool's 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, clear sentence that directly states the tool's purpose without unnecessary words. It's front-loaded and efficiently communicates the core function, 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?

Given the tool's low complexity (one optional parameter) and high schema coverage, the description is minimally adequate. However, with no annotations and no output schema, it lacks details on behavioral traits and return values, which could hinder the agent's ability to use it effectively in all contexts.

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

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

The input schema has 100% description coverage, with the 'site' parameter fully documented in the schema itself. The description doesn't add any extra meaning beyond what's in the schema, so it meets the baseline score of 3 for high schema coverage without compensating value.

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

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

The description clearly states the action ('Get') and resource ('cache statistics for a WordPress site'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'wp_cache_info' or 'wp_performance_stats', which might provide similar or overlapping functionality, so it doesn't reach the highest score.

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. With siblings like 'wp_cache_info' and 'wp_performance_stats' available, there's no indication of how this tool differs or when it should be preferred, leaving the agent to guess based on names alone.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. While 'pre-warm' implies a read operation that populates cache, it doesn't specify whether this is a background process, how long it takes, what permissions are required, whether it affects site performance during execution, or what happens on failure. For a tool with zero annotation coverage, this leaves significant behavioral questions unanswered.

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 gets straight to the point with zero wasted words. It's appropriately sized for a single-parameter tool and front-loads the essential information.

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

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

Given the complexity of cache operations and the complete lack of annotations and output schema, the description is insufficiently complete. It doesn't explain what 'essential WordPress data' includes, what the tool returns (success/failure indicators, metrics), performance implications, or error conditions. For a tool that likely involves system-level operations, more context is needed.

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

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

Schema description coverage is 100%, so the schema already documents the single 'site' parameter. The description doesn't add any parameter-specific information beyond what's in the schema. According to scoring rules, when schema coverage is high (>80%), the baseline is 3 even with no param info in the description.

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

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

The description clearly states the action ('pre-warm cache') and the target ('with essential WordPress data'), providing a specific verb+resource combination. However, it doesn't explicitly differentiate from sibling cache tools like wp_cache_clear or wp_cache_info, which would be needed for a perfect score.

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

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. There's no mention of when pre-warming is appropriate, what 'essential WordPress data' means, or how this differs from other cache-related tools like wp_cache_clear or wp_cache_info. The agent receives no usage context.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. While 'creates' implies a write operation, it doesn't specify whether this requires admin permissions, what happens on success/failure, whether the password is displayed only once, or any rate limits. For a security-sensitive operation like password creation, this is insufficient.

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

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

The description is a single, efficient sentence that gets straight to the point with zero wasted words. It's appropriately sized for a straightforward creation operation and front-loads the 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?

For a tool that creates application passwords (a security-sensitive write operation) with no annotations and no output schema, the description is inadequate. It doesn't explain what the tool returns, what permissions are required, or any security implications. The context demands more comprehensive disclosure.

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

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

The description mentions creating a password 'for a user' which aligns with the user_id parameter, but doesn't add meaningful context beyond what's already in the schema descriptions. With 100% schema description coverage, the baseline is 3, and the description doesn't significantly enhance parameter understanding.

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

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

The description clearly states the action ('creates') and resource ('new application password for a user'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'wp_get_application_passwords' or 'wp_delete_application_password' beyond the obvious verb difference.

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. There's no mention of prerequisites (like authentication requirements), when this operation is appropriate, or how it relates to sibling tools like 'wp_get_application_passwords' or 'wp_delete_application_password'.

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 provided, so the description carries full burden for behavioral disclosure. 'Creates' implies a write/mutation operation, but the description doesn't mention authentication requirements, permission levels needed, whether the operation is idempotent, what happens on duplicate names, or what the return value looks like. For a mutation tool with zero annotation coverage, this is insufficient.

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

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

The description is extremely concise - just three words. It's front-loaded with the essential action and resource. There's zero wasted language or unnecessary elaboration. Every word earns its place in conveying 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?

For a mutation tool (category creation) with no annotations and no output schema, the description is inadequate. It doesn't explain what happens after creation, what permissions are required, how to handle errors, or what the tool returns. The context signals show this is a 3-parameter tool with one required parameter, but the description provides no guidance on parameter importance or usage patterns.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters thoroughly. The description adds no additional parameter information beyond what's in the schema. According to scoring rules, when schema coverage is high (>80%), the baseline is 3 even with no param info in the description.

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

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

The description clearly states the action ('creates') and resource ('new category'), making the purpose immediately understandable. However, it doesn't differentiate this tool from other creation tools like wp_create_post or wp_create_tag, which would require a 5. The verb+resource combination is specific but lacks sibling differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives. With sibling tools like wp_update_category and wp_list_categories available, there's no indication of when creation is appropriate versus updating or listing. The description offers no context about prerequisites, use cases, 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?

With no annotations provided, the description carries full burden for behavioral disclosure. It states this is a creation operation but doesn't mention authentication requirements, rate limits, whether the comment appears immediately or needs approval, or what happens on success/failure. For a write operation with zero annotation coverage, this is insufficient.

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

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

The description is a single, focused sentence with zero wasted words. It's perfectly front-loaded with the core action and target, making it immediately understandable without any 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?

For a write operation (comment creation) with no annotations and no output schema, the description is incomplete. It doesn't address authentication needs, success/failure behavior, moderation status, or return values. Given the complexity of creating user-generated content in WordPress, more context is needed.

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

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

Schema description coverage is 100%, so the schema already documents all 5 parameters thoroughly. The description doesn't add any parameter-specific information beyond what's in the schema descriptions, so it meets the baseline expectation but doesn't provide extra value.

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

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

The description clearly states the action ('creates a new comment') and the target resource ('on a post'), making the purpose immediately understandable. It doesn't explicitly differentiate from sibling tools like wp_update_comment or wp_approve_comment, which would be needed for a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives like wp_update_comment for modifying existing comments or wp_approve_comment for moderation actions. There's no mention of prerequisites, constraints, or typical use cases.

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?

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Creates a new page' implies a write/mutation operation, but the description doesn't disclose what permissions are required, whether the creation is immediate or scheduled, what happens on failure, or what the response contains. For a mutation tool with zero annotation coverage, this leaves significant behavioral gaps.

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

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

The description is maximally concise - a single three-word sentence that communicates the core function without any wasted words. It's front-loaded with the essential information and earns its place 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 mutation tool with no annotations and no output schema, the description is insufficiently complete. It doesn't explain what happens after creation (e.g., returns a page ID, redirects, or provides confirmation), what error conditions might occur, or any side effects. The combination of mutation operation + missing annotations + no output schema requires more descriptive context than provided.

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

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

The schema description coverage is 100%, so all parameters are documented in the input schema. The description adds no additional parameter information beyond what's already in the schema descriptions. According to the scoring rules, when schema coverage is high (>80%), the baseline is 3 even with no param info in the description.

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

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

The description clearly states the action ('creates') and resource ('new page'), making the purpose immediately understandable. It distinguishes itself from siblings like wp_create_post (which creates posts) and wp_update_page (which updates existing pages). However, it doesn't specify that this is for WordPress specifically, though the tool name provides that context.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to choose wp_create_page over wp_create_post (for different content types), or when to use wp_update_page instead (for modifying existing pages). There's also no mention of prerequisites like authentication or site configuration.

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?

With no annotations provided, the description carries the full behavioral burden. It does disclose two useful traits beyond the schema: input validation occurs and the success response includes management links. But it says nothing about required capabilities/authentication, error behavior, or what happens to defaults such as status when omitted, so a mutation tool remains only partially covered.

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 summary sentence is front-loaded and the examples are scannable, each illustrating a distinct capability rather than repeating itself. Seven examples is on the verbose side, but none is pure 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?

There is no output schema, and while the description notes that success feedback with management links is returned, it never details the response shape or failure modes. Combined with no annotations on a write tool, the definition covers invocation but leaves the agent guessing about permissions, validation failures, and sibling selection.

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

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

Schema coverage is reported as 100%, but the schema contains only the 'site' parameter, while the description documents title, content, excerpt, status, categories, tags, featured_media, and date through examples. It adds real meaning the schema lacks, including the ISO-8601 date format for scheduled posts and the featured_media=0 convention for removal, though array encoding (categories=[1,5]) is shown without explanation.

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

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

The first sentence names a specific verb and resource ('Creates a new WordPress post') and adds behavioral promises ('comprehensive validation and detailed success feedback including management links'). It is clear, but it never explicitly distinguishes this tool from close siblings such as wp_create_page or wp_update_post, so the agent must infer the boundary from the name alone.

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 seven worked examples demonstrate concrete usage scenarios (simple, draft, scheduled, categorized, featured media, complete), which implicitly tells the agent when particular options apply. However, there is no guidance on when to choose this tool over wp_create_page or wp_update_post, no prerequisites, and no exclusions.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. 'Creates a new tag' implies a write/mutation operation, but provides no information about permissions required, whether the operation is idempotent, what happens on duplicate names, or what the response contains. For a creation tool with zero annotation coverage, this is insufficient behavioral context.

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

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

The description is maximally concise - a single three-word sentence that communicates the core purpose without any wasted words. It's appropriately sized for a simple creation tool and front-loads the essential information.

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

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

For a creation/mutation tool with no annotations and no output schema, the description is incomplete. It doesn't address behavioral aspects like permissions, idempotency, error conditions, or response format. While the schema covers parameters well, the tool's operational context and expected outcomes remain undocumented.

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

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

Schema description coverage is 100%, so the schema already fully documents both parameters (site and name). The description adds no additional parameter information beyond what's in the schema. According to scoring rules, when schema coverage is high (>80%), the baseline is 3 even with no param info in the description.

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

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

The description 'Creates a new tag' clearly states the verb ('creates') and resource ('tag'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like wp_create_category or wp_create_post, which follow the same pattern for different WordPress entities.

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 doesn't mention when tag creation is appropriate compared to category creation, or what prerequisites might be needed (like authentication status). The only usage context comes from the schema's site parameter description, not the tool description itself.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Creates a new user' indicates a write/mutation operation but reveals nothing about permissions required, whether the operation is idempotent, what happens on duplicate usernames/emails, or what the response contains. For a user creation tool with significant security implications, this minimal description leaves critical behavioral aspects unspecified.

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 maximally concise at three words, with zero wasted language. It's front-loaded with the essential action and resource. Every word earns its place, making it immediately scannable and understandable 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?

Given this is a user creation tool with no annotations and no output schema, the description is insufficiently complete. It doesn't address authentication requirements, error conditions, return values, or security implications. The description should provide more context about what 'creating a user' entails in this WordPress context, especially since there's no structured output documentation.

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

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

The input schema has 100% description coverage, with each parameter well-documented in the schema itself. The description adds no additional parameter information beyond what's already in the schema. According to scoring rules, when schema_description_coverage is high (>80%), the baseline is 3 even with no param info in the description, which 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 clearly states the verb ('Creates') and resource ('new user'), making the purpose immediately understandable. It distinguishes itself from sibling tools like wp_update_user or wp_delete_user by specifying creation rather than modification or deletion. However, it doesn't explicitly differentiate from wp_create_application_password which also creates a user-related resource, so it doesn't reach the highest level of sibling differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives. There's no mention of prerequisites (like authentication requirements), when not to use it, or how it relates to similar tools like wp_update_user or wp_get_user. The agent must infer usage context entirely from the tool name and input schema.

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?

With no annotations provided, the description carries full burden for behavioral disclosure. While 'revokes' implies a destructive operation, it doesn't specify whether this action is reversible, what permissions are required, or what happens to applications using the password. No rate limits, error conditions, or confirmation behavior are mentioned.

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

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

The description is a single, focused sentence with zero wasted words. It's front-loaded with the core action and resource, making it immediately understandable 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?

For a destructive operation with no annotations and no output schema, the description is insufficient. It doesn't explain what 'revokes' entails operationally, what the expected outcome is, or any error scenarios. Given the complexity of application password management and the lack of structured behavioral information, more context is needed.

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

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

Schema description coverage is 100%, so all parameters are documented in the schema. The description doesn't add any additional semantic context about the parameters beyond what's already in the schema descriptions. The baseline score of 3 reflects adequate but not enhanced parameter documentation.

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

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

The description clearly states the action ('revokes') and resource ('existing application password'), making the purpose immediately understandable. It doesn't explicitly distinguish from sibling tools like 'wp_delete_user' or 'wp_delete_post', but the specific resource type (application password) provides adequate differentiation.

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

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

No guidance is provided about when to use this tool versus alternatives. The description doesn't mention prerequisites (like needing the user_id and uuid from 'wp_get_application_passwords'), nor does it clarify when revocation is appropriate versus creating new passwords or other user management operations.

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

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

No annotations are provided, so the description carries full burden. 'Deletes a category' implies a destructive mutation, but it doesn't disclose critical behavioral traits: whether deletion is permanent, what happens to associated posts, required permissions, error conditions, or rate limits. For a destructive tool with zero annotation coverage, this is a significant gap.

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

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

The description is extremely concise ('Deletes a category.')—a single sentence with no wasted words. It's front-loaded with the core action, though it could benefit from additional context. The brevity is efficient but borders on under-specification.

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 (destructive operation with 2 parameters), lack of annotations, and no output schema, the description is incomplete. It doesn't cover behavioral aspects, usage context, or output expectations. For a deletion tool in a rich sibling set, this minimal description leaves too many gaps for effective agent 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 100%, with clear documentation for both parameters (site and id). The description adds no parameter semantics beyond what the schema provides—it doesn't explain parameter relationships, constraints, or examples. With high schema coverage, the baseline 3 is appropriate as the description doesn't compensate but doesn't detract either.

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 'Deletes a category' clearly states the action (delete) and resource (category), but it's overly simplistic and doesn't differentiate from sibling deletion tools like wp_delete_post, wp_delete_comment, or wp_delete_tag. It specifies what it does but lacks the specificity needed for a 4 or 5 score.

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. The description doesn't mention prerequisites (e.g., needing category ID), exclusions (e.g., cannot delete default categories), or related tools like wp_update_category or wp_list_categories. This leaves the agent without context for proper tool selection.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. While 'deletes' implies a destructive mutation, it doesn't specify important behavioral details: whether deletion requires specific permissions, what happens to associated data, if the action is reversible, or what the response looks like. The description adds minimal context beyond the basic action.

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

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

The description is perfectly concise at just three words. It's front-loaded with the essential action and resource, with zero wasted words. Every element earns its place in this minimal but complete statement of 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?

For a destructive mutation tool with no annotations and no output schema, the description is insufficiently complete. It doesn't address important contextual aspects: what permissions are needed, whether the action is reversible, what happens to the comment data, or what the tool returns. The combination of a destructive operation with minimal description creates significant gaps for an AI 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?

The input schema has 100% description coverage, providing complete documentation for all three parameters. The description adds no additional parameter information beyond what's already in the schema. According to scoring rules, when schema_description_coverage is high (>80%), the baseline is 3 even with no param info in the description.

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

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

The description clearly states the action ('deletes') and resource ('a comment'), making the purpose immediately understandable. However, it doesn't differentiate this tool from sibling deletion tools like wp_delete_category or wp_delete_post, which follow the same pattern but target different resources.

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 doesn't mention sibling tools like wp_spam_comment or wp_update_comment that might be relevant alternatives, nor does it specify prerequisites such as needing comment deletion permissions or when deletion versus updating might be appropriate.

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

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

With no annotations provided, the description carries full burden but only states the basic action. It doesn't disclose that this is a destructive operation, what permissions are required, whether deletion is reversible (via trash), rate limits, or what happens to associated files. The 'force' parameter in the schema hints at trash behavior, but the description doesn't explain 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?

The description is a single, direct sentence with zero wasted words. It's front-loaded with the core action and resource, making it immediately scannable and efficient.

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

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

For a destructive tool with no annotations and no output schema, the description is inadequate. It doesn't cover behavioral aspects like irreversibility, permissions, or response format. Given the complexity of a delete operation in WordPress (with trash functionality hinted in schema), more context is needed.

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

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

Schema description coverage is 100%, so parameters are fully documented in the schema. The description adds no additional parameter context beyond what's in the schema (like explaining what a 'media item' ID refers to or site targeting logic). Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the verb ('Deletes') and resource ('a media item'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like wp_delete_post or wp_delete_comment, which follow the same pattern for different resource types.

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. The description doesn't mention prerequisites, when deletion is appropriate, or how it relates to other deletion tools (like wp_delete_post for posts). The agent must infer usage from the tool name alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Deletes a page' implies a destructive mutation but doesn't specify whether this requires admin permissions, whether deletion is permanent or reversible, what happens to associated content, or what the response looks like. The description mentions nothing about error conditions, rate limits, or side effects beyond the basic action.

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

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

The description is extremely concise at just two words ('Deletes a page'), which efficiently communicates the core purpose without any wasted language. It's front-loaded with the essential information, though this brevity comes at the cost of missing important contextual 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 destructive mutation tool with no annotations and no output schema, the description is inadequate. It doesn't explain what happens after deletion, what permissions are required, whether the action can be undone, or what the return value looks like. Given the complexity of a deletion operation in WordPress (with trash functionality, permissions, and potential side effects), the description should provide more complete context.

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

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

The input schema has 100% description coverage, with all three parameters (site, id, force) well-documented in the schema itself. The description adds no additional parameter information beyond what's already in the schema, so it meets the baseline of 3 where the schema does the heavy lifting for parameter documentation.

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

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

The description 'Deletes a page' clearly states the action (delete) and resource (page), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like wp_delete_post or wp_delete_media, which perform similar deletion operations on different resource types.

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 doesn't mention when to choose wp_delete_page over wp_delete_post (for deleting posts instead of pages) or wp_delete_media (for deleting media files), nor does it discuss prerequisites like authentication or permissions needed for deletion operations.

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

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

No annotations are provided, so the description carries the entire behavioral burden. It claims 'safety confirmations and detailed feedback' without saying what is confirmed or what feedback is returned, and says nothing about permissions, cascading effects on revisions/comments/media, or reversibility beyond trash. The vague reassurance is close to filler rather than 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 opening sentence is well front-loaded, but the bulk of the text is CLI examples that mirror a command-line interface the MCP tool does not expose. The formatting is clean, yet a large share of the content does not earn its place against the actual schema.

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 operation with no annotations and no output schema, the description covers the trash/permanent axis but omits what data is destroyed alongside the post, any permission requirements, and the meaning of the only real parameter. It is minimum viable, not 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 schema has exactly one parameter ('site', 100% documented), yet the description presents CLI-style flags (`--id=123`, `--force=true`) that do not exist in the schema. An agent could try to pass id/force based on this text, making the description actively misleading about the call surface rather than additive.

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?

States a specific verb+resource ('Deletes a WordPress post') and immediately distinguishes itself from the sibling wp_delete_page by naming the entity type. The trash vs. permanent distinction further sharpens what this 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 usage examples give concrete conditions: default behavior trashes, `--force=true` permanently deletes, and bulk means multiple calls. However, it never states when to prefer trashing over permanent deletion or any preconditions, so an agent gets context but not 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?

With no annotations provided, the description carries full burden for behavioral disclosure. While 'Deletes' implies a destructive mutation, it doesn't specify whether this is permanent, requires admin permissions, affects associated posts, or what happens on success/failure. This leaves critical behavioral traits undocumented.

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

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

The description is maximally concise with just three words, front-loading the essential action and resource. There's zero wasted language, making it immediately scannable and efficient.

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

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

For a destructive mutation tool with no annotations and no output schema, the description is insufficient. It doesn't explain what happens after deletion, error conditions, or provide context about the WordPress tag system. The agent must infer too much from minimal information.

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

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

Schema description coverage is 100%, with both parameters well-documented in the schema. The description adds no additional parameter information beyond what's already in the structured fields, meeting the baseline expectation when schema coverage is complete.

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

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

The description clearly states the action ('Deletes') and resource ('a tag'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like wp_delete_category or wp_delete_post, which follow the same pattern but target different resources.

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 doesn't mention prerequisites (like needing tag ID from wp_get_tag or wp_list_tags), nor does it warn about irreversible deletion or suggest when wp_update_tag might be more appropriate.

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

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

No annotations are provided, so the description carries full burden. 'Deletes a user' implies a destructive, irreversible mutation, but it doesn't disclose critical behavioral traits: whether deletion is permanent, what happens to user content (hinted by 'reassign' parameter but not explained), authentication requirements, error conditions, or rate limits. This is inadequate for a destructive tool with zero annotation coverage.

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

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

The description is extremely concise—just three words—and front-loaded with the core action. There's zero wasted text, making it easy to parse quickly, though this conciseness comes at the cost of completeness in other dimensions.

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 this is a destructive mutation tool with no annotations and no output schema, the description is incomplete. It doesn't explain the impact of deletion, what 'reassign' does in practice, potential side effects, or what the tool returns (e.g., success/failure). For such a high-stakes operation, more context is needed to use it safely and effectively.

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

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

Schema description coverage is 100%, so the schema fully documents all three parameters (site, id, reassign) with clear descriptions. The description adds no parameter information beyond what's in the schema, which is acceptable given the high coverage—baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the verb ('Deletes') and resource ('a user'), making the purpose immediately understandable. However, it doesn't differentiate from sibling deletion tools like wp_delete_category, wp_delete_comment, etc., which all follow the same 'Deletes a [resource]' pattern, so it lacks sibling distinction.

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 doesn't mention prerequisites (e.g., user must exist), exclusions (e.g., cannot delete current user), or related tools like wp_get_user for verification or wp_update_user for modification instead of deletion.

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?

With no annotations provided, the description carries full burden for behavioral disclosure. It states it's a list operation, implying read-only behavior, but doesn't specify permissions required (e.g., admin access), rate limits, pagination, error conditions, or output format. For a tool accessing sensitive data like passwords, this lack of detail is a significant gap in transparency.

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

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

The description is a single, clear sentence with zero wasted words. It's front-loaded with the core action ('Lists application passwords') and specifies the target ('for a specific user'). No extraneous information or redundancy is present, making it highly efficient.

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

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

Given the tool's complexity (accessing sensitive user data), lack of annotations, and no output schema, the description is insufficiently complete. It doesn't cover behavioral aspects like authentication needs, data sensitivity, error handling, or return format. For a tool with no structured safety or output guidance, the description should provide more context to ensure safe and effective 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 100%, with both parameters (site and user_id) well-documented in the schema. The description adds no additional parameter semantics beyond what's in the schema (e.g., no examples, format details, or constraints). According to guidelines, with high schema coverage, the baseline is 3 even without param info in the description.

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

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

The description clearly states the tool's purpose with a specific verb ('Lists') and resource ('application passwords for a specific user'). It distinguishes from sibling tools like wp_create_application_password and wp_delete_application_password by focusing on retrieval rather than creation or deletion. However, it doesn't explicitly differentiate from other list tools like wp_list_users or wp_list_posts, which slightly limits sibling differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., user must exist), exclusions (e.g., cannot list passwords for non-existent users), or comparisons to other tools (e.g., wp_get_user for general user info vs. this for passwords). This leaves the agent without contextual usage cues.

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?

With no annotations provided, the description carries the full burden of behavioral disclosure. While it indicates this is a read operation ('Gets'), it doesn't specify what information the authentication status includes, whether it requires specific permissions, what happens when authentication fails, or what the response format looks like. For a tool that checks system state with zero annotation coverage, this leaves significant behavioral questions unanswered.

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 immediately communicates the tool's purpose without unnecessary words. It's appropriately sized for a simple status-checking tool and front-loads the essential information.

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

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

For a simple status-checking tool with one well-documented parameter and no output schema, the description is minimally adequate. However, without annotations or output schema, it should ideally provide more context about what 'authentication status' includes and what the response looks like. The description meets basic requirements but leaves room for improvement given the lack of structured behavioral information.

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

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

The schema description coverage is 100%, with the single parameter 'site' already well-documented in the schema. The description doesn't add any additional parameter information beyond what's in the schema. With high schema coverage and only one parameter, the baseline score of 3 is appropriate - the schema does the heavy lifting for parameter documentation.

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

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

The description clearly states the action ('Gets') and the resource ('current authentication status for a configured WordPress site'), making the purpose immediately understandable. However, it doesn't explicitly differentiate this from sibling tools like 'wp_test_auth' or 'wp_switch_auth_method', which also relate to authentication functionality.

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 ('for a configured WordPress site'), but doesn't provide explicit guidance on when to use this tool versus alternatives like 'wp_test_auth' or 'wp_switch_auth_method'. There's no mention of prerequisites, typical use cases, or when this tool would be preferred over other authentication-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?

With no annotations provided, the description carries full burden but only states the basic operation. It doesn't disclose behavioral aspects like authentication requirements, error handling, rate limits, or what happens if the ID doesn't exist. For a read operation with zero annotation coverage, this is insufficient.

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

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

The description is a single, clear sentence with no wasted words. It's front-loaded with the core purpose and appropriately sized for a simple retrieval tool.

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

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

For a simple read operation with good schema coverage but no annotations or output schema, the description is minimally adequate. It states what the tool does but lacks important context about authentication, error cases, and relationship to sibling tools that would make it more complete.

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

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

Schema description coverage is 100%, so the schema already documents both parameters thoroughly. The description doesn't add any parameter semantics beyond what's in the schema, which is acceptable given the comprehensive schema documentation.

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

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

The description clearly states the action ('retrieves') and resource ('a single category'), making the purpose immediately understandable. However, it doesn't explicitly differentiate this from sibling tools like 'wp_list_categories' or 'wp_get_post', which would require 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?

No guidance is provided on when to use this tool versus alternatives like 'wp_list_categories' for multiple categories or other 'wp_get_*' tools for different resources. The description only states what it does, not when it's appropriate.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states it 'retrieves' (implying read-only), but doesn't clarify authentication requirements, rate limits, error handling (e.g., what happens if ID doesn't exist), or response format. For a read operation with zero annotation coverage, this leaves significant gaps in understanding how the tool behaves beyond its basic function.

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

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

The description is a single, clear sentence with zero wasted words. It's front-loaded with the core action and resource, making it immediately understandable. Every word earns its place by conveying essential information without redundancy.

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

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

Given the tool's low complexity (simple retrieval), high schema coverage (100%), and lack of output schema, the description is minimally adequate. It covers the basic 'what' but misses behavioral context (especially with no annotations) and usage guidance. For a read operation in a crowded sibling set, more context would help the agent use it appropriately.

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

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

Schema description coverage is 100%, with both parameters (site and id) well-documented in the schema. The description adds no additional parameter semantics beyond what the schema already provides—it doesn't explain ID format, site configuration details, or parameter interactions. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the action ('Retrieves') and resource ('a single comment by its ID'), making the purpose specific and unambiguous. It distinguishes from sibling tools like wp_list_comments (which lists multiple comments) and wp_create_comment (which creates comments). However, it doesn't explicitly mention the WordPress context or differentiate from other 'get' tools like wp_get_post.

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 doesn't mention when to choose wp_get_comment over wp_list_comments for single vs. multiple comments, or when to use it in relation to wp_update_comment or wp_delete_comment. There's no context about prerequisites, error conditions, or typical workflows.

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?

With no annotations provided, the description carries the full burden. It clearly indicates this is a read operation ('Retrieves') and specifies what information is returned (profile, roles, capabilities, account details). However, it doesn't mention authentication requirements, error conditions, or rate limits that would be important for a tool accessing user data.

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

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

The description is well-structured with a clear purpose statement followed by bulleted usage examples. Every sentence earns its place by providing specific guidance. It could be slightly more concise by integrating the examples more tightly with the main description.

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

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

For a read-only tool with no output schema and no annotations, the description provides good coverage of purpose, usage, and return information. It explains what data is returned (profile, roles, capabilities, account details) which compensates for the missing output schema. The main gap is lack of behavioral details like authentication requirements.

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

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

The schema has 100% description coverage for its single optional parameter, so the baseline is 3. The description doesn't mention parameters directly, but the usage examples imply no parameters are needed for basic use ('Get current user: wp_get_current_user'), which adds context about when the optional 'site' parameter is required (only for multi-site configurations).

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 specific action ('Retrieves') and resource ('the currently authenticated user') with detailed scope ('comprehensive profile information including roles, capabilities, and account details'). It distinguishes from sibling tools like wp_get_user (which retrieves a specific user) by focusing on the current authenticated user context.

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

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

The description provides explicit usage examples that clarify when to use this tool: for getting current user info, checking permissions, account verification, and viewing profile details. It implicitly distinguishes from alternatives like wp_get_user (which requires a user ID) by focusing on the authenticated context without needing parameters.

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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool retrieves data (implying read-only), but doesn't mention authentication requirements, rate limits, error handling, or what happens if the ID doesn't exist. For a tool with zero annotation coverage, this leaves significant behavioral gaps.

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

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

The description is a single, clear sentence that efficiently conveys the core purpose without unnecessary words. It's front-loaded with the essential information and has zero wasted content, making it easy to parse quickly.

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

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

Given the tool's low complexity (simple retrieval), high schema coverage, and lack of output schema, the description is minimally adequate. However, it doesn't address behavioral aspects like authentication or error handling, which would be helpful for a tool with no annotations. It meets basic needs but leaves room for improvement.

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

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

The schema description coverage is 100%, with both parameters ('site' and 'id') well-documented in the schema. The description doesn't add any meaningful parameter semantics beyond what's already in the schema (e.g., it doesn't clarify ID format or site selection logic). Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the action ('retrieves') and resource ('a single media item by its ID'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'wp_list_media' (which lists multiple items) or 'wp_get_post' (which retrieves a different resource type), missing full sibling differentiation.

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

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

The description implies usage context (when you need a specific media item by ID) but doesn't provide explicit guidance on when to use this versus alternatives like 'wp_list_media' for browsing or 'wp_update_media' for modifications. No exclusions or prerequisites are mentioned, leaving usage somewhat open to interpretation.

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 provided, so the description carries the full behavioral burden, and 'Retrieves' only weakly implies a safe read. It omits what happens for an invalid or missing ID, whether authentication is required, and how the 'site' targeting behaves when multiple sites are configured.

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 zero filler; the verb and lookup key come first. It is efficient, though its terseness is closer to under-specification than to disciplined brevity.

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

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

For a simple two-parameter read tool with full schema coverage this is minimally adequate, but with no annotations and no output schema the agent still lacks any sense of the returned page shape or failure behavior, which the description could have supplied in one clause.

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

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

Schema description coverage is 100% and both parameters (id, site) are documented in the schema, so the schema does the heavy lifting. The description only restates the ID lookup ('by its ID') and adds nothing about the site parameter's fallback behavior, making the baseline 3 appropriate.

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

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

States a specific verb (retrieves) and resource (a single page) plus the lookup key (ID), so an agent immediately knows this is a point-read rather than a list. However, it offers no differentiation from adjacent siblings such as wp_get_page_revisions, wp_list_pages, or wp_get_post, which an agent could plausibly confuse it with.

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 when-to-use context: it does not say to call wp_list_pages first to discover an ID, nor when to prefer wp_get_page_revisions over this tool. Nothing is said about prerequisites or exclusions, leaving routing entirely to inference from the name.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool retrieves data, implying a read-only operation, but doesn't specify authentication needs, rate limits, error conditions, or the format of returned revisions. This leaves significant behavioral aspects undocumented.

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

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

The description is a single, clear sentence with no wasted words. It's front-loaded with the core purpose, making it efficient and easy to parse, which is ideal for conciseness.

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

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

Given the lack of annotations and output schema, the description is incomplete. It doesn't explain what the tool returns (e.g., revision details, format), potential side effects, or error handling. For a retrieval tool with no structured output documentation, this leaves critical 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 100%, so the schema fully documents both parameters ('site' and 'id'). The description adds no additional parameter semantics beyond what's in the schema, such as format examples or constraints, meeting the baseline for high schema coverage.

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

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

The description clearly states the action ('Retrieves') and resource ('revisions for a specific page'), making the purpose understandable. However, it doesn't differentiate from the sibling tool 'wp_get_post_revisions' which appears to serve a similar function for posts rather than pages, leaving some ambiguity about sibling distinction.

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. The description doesn't mention prerequisites, context, or comparisons to sibling tools like 'wp_get_post_revisions' or 'wp_get_page', leaving the agent to infer usage scenarios independently.

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 supplied, so the description carries the full behavioral burden. It usefully discloses the shape of the return payload (metadata, content statistics, management links), which substitutes for the missing output schema, but says nothing about read-only safety, required capabilities, or behavior when the post ID is invalid or missing.

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 verb and resource first and no wasted clauses. The trailing 'including ...' enumeration is justified because no output schema exists, though it is slightly list-like.

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 single-parameter read tool with a fully documented schema and no annotations, the description covers the essentials and even compensates for the absent output schema by naming what is returned. Missing only minor details such as error behavior for unknown post IDs.

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?

Only one parameter (`site`), and schema description coverage is 100%, with the schema explaining the multi-site targeting rule. The description adds no parameter context, which is acceptable here since nothing is undocumented, but it earns no credit above the baseline.

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

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

State a specific verb+resource ('Retrieves ... a single post') and enumerates the payload (metadata, content statistics, management links), which sets it apart from list-style siblings like wp_list_posts. It does not explicitly name the sibling alternatives (wp_get_post_revisions, wp_list_posts), so it stops 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?

There is no when-to-use guidance at all: no statement of when to call this versus wp_list_posts for browsing or wp_get_post_revisions for revision history, no prerequisites, and no exclusions. The agent must infer the retrieval use case from the name alone.

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 provided, so the description carries the full behavioral burden. It discloses what the response contains (changes, dates, authors) and implies a read-only operation via 'Retrieves,' but says nothing about permissions, pagination, result limits, or whether revisions are returned in full. Partial 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?

A single front-loaded sentence with the core action first. The trailing 'for content management and auditing purposes' is mild filler that doesn't earn its place, but overall the structure is efficient.

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

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

A simple read-only tool with one schema-documented parameter and no output schema. The description covers the resource, the return contents, and the purpose, which is close to adequate for this complexity, though it omits pagination/scope behavior.

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?

Only one parameter (site), and schema description coverage is 100%, so the schema already documents it fully. The description adds no meaning about the site parameter or how multi-site targeting behaves. Baseline 3 applies when the schema does the heavy lifting.

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

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

States a specific verb and resource: 'Retrieves the revision history for a specific post.' The noun 'post' distinguishes it from wp_get_page_revisions, but the description never explicitly acknowledges that sibling to sharpen the boundary. Clear purpose, no explicit sibling differentiation.

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

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

The trailing clause 'for content management and auditing purposes' implies a usage context but gives no when-to-use guidance, prerequisites, or alternatives to consider (e.g. wp_get_page_revisions for pages). Usage 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?

With no annotations provided, the description carries full burden for behavioral disclosure. It states this is a retrieval operation but doesn't mention authentication requirements, rate limits, error conditions, or what format the settings are returned in. For a read operation with zero annotation coverage, this leaves significant behavioral gaps.

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

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

The description is a single, efficient sentence that gets straight to the point with no wasted words. It's appropriately sized for a simple retrieval tool and front-loads the essential information.

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

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 optional parameter and no output schema, the description is minimally adequate. However, with no annotations and no output schema, it should ideally provide more context about what 'general settings' includes and the return format. The description meets basic requirements but leaves the agent guessing about the output 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?

The description adds no parameter information beyond what's already in the schema (which has 100% coverage). The schema fully documents the single optional 'site' parameter with its purpose and requirement condition. The description doesn't provide additional context about parameter usage or semantics.

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

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

The description clearly states the verb ('Retrieves') and resource ('general settings for a WordPress site'), making the purpose immediately understandable. It doesn't explicitly differentiate from sibling tools like wp_update_site_settings, but the verb 'retrieves' vs 'updates' provides implicit distinction.

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. There's no mention of when this tool is appropriate versus other settings-related tools or what prerequisites might be needed. The agent must infer usage from the tool name alone.

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

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

No annotations are provided, so the description carries full burden. It states the tool retrieves data (implying read-only), but doesn't disclose authentication requirements, error handling, rate limits, or what happens if the tag doesn't exist. For a read operation with no annotation coverage, this leaves significant behavioral gaps.

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

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

The description is a single, efficient sentence that states the core purpose without unnecessary words. It's appropriately sized for a simple retrieval tool and front-loads the essential information.

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

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

For a simple read operation with 100% schema coverage but no annotations or output schema, the description is minimally adequate. It states what the tool does but lacks behavioral context and usage guidance. The absence of output schema means the description should ideally mention return format, but it doesn't.

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

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

Schema description coverage is 100%, so the schema already fully documents both parameters. The description adds no additional parameter semantics beyond what's in the schema (e.g., it doesn't explain tag ID format or site configuration details). Baseline 3 is appropriate when schema does all the work.

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

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

The description clearly states the action ('retrieves') and resource ('a single tag'), making the purpose immediately understandable. It specifies retrieval by ID, which distinguishes it from list operations. However, it doesn't explicitly differentiate from sibling tools like wp_get_category or wp_get_post that follow the same pattern.

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. The description doesn't mention wp_list_tags for listing multiple tags, nor does it explain prerequisites like authentication or site configuration. Usage context is implied but not articulated.

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?

With no annotations provided, the description carries full burden for behavioral disclosure. While 'retrieves' implies a read-only operation, it doesn't specify authentication requirements, rate limits, error responses, or what happens when the user ID doesn't exist. For a tool with zero annotation coverage, this leaves significant behavioral gaps.

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

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

The description is a single, efficient sentence that states the core functionality without unnecessary words. It's front-loaded with the main action and resource, making it immediately understandable. Every word earns its place in this minimal but complete statement of 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 retrieval tool with good schema coverage but no annotations or output schema, the description is adequate but has clear gaps. It covers the basic purpose but lacks behavioral context, usage guidance, and information about return values. Given the tool's relative simplicity among siblings, this represents a minimum viable description.

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

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

Schema description coverage is 100%, so the schema already documents both parameters thoroughly. The description adds no additional parameter information beyond what's in the schema. It mentions 'by their ID' which aligns with the 'id' parameter but provides no extra context about parameter relationships or usage examples.

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 ('retrieves') and resource ('a single user'), making the purpose immediately understandable. It specifies retrieval by ID, which distinguishes it from list operations like wp_list_users. However, it doesn't explicitly differentiate from wp_get_current_user which also retrieves user data but without requiring an ID parameter.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention wp_list_users for listing multiple users, wp_get_current_user for getting the authenticated user, or wp_update_user for modifying user data. There's no context about prerequisites, authentication requirements, or error conditions.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure but offers minimal information. It states it 'lists categories' which implies a read-only operation, but doesn't mention pagination behavior, rate limits, authentication requirements, error conditions, or what the output format looks like. For a tool with no annotation coverage, this is inadequate.

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

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

The description is a single, clear sentence with zero wasted words. It's appropriately sized for a simple list operation and front-loads the core purpose immediately. Every word earns its place.

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

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

Given the lack of annotations and output schema, the description is incomplete. For a list operation with three parameters, it should at minimum mention typical use cases, output format expectations, or behavioral constraints. The description provides only the bare minimum purpose statement without addressing the tool's 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?

The schema description coverage is 100%, so all parameters are documented in the schema itself. The description doesn't add any parameter semantics beyond what's already in the schema descriptions. According to scoring rules, when schema coverage is high (>80%), the baseline is 3 even with no param info in the description.

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

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

The description clearly states the verb ('Lists') and resource ('categories from a WordPress site'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling list tools like wp_list_posts or wp_list_tags, though the resource specificity provides some implicit distinction.

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. There's no mention of when to choose wp_list_categories over wp_get_category (for single category retrieval) or wp_search_site (for broader searching), nor any context about prerequisites or typical use cases.

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 provided, so the description carries the full burden. It mentions 'with filters' but doesn't disclose key behavioral traits such as pagination, rate limits, authentication requirements, or what happens if no filters are applied (e.g., returns all comments). For a list operation with no annotation coverage, this leaves significant gaps in understanding how the tool behaves.

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

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

The description is a single, efficient sentence that front-loads the core purpose ('Lists comments from a WordPress site') and adds a useful qualifier ('with filters'). There is zero waste or redundancy, making it appropriately sized for its 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?

Given the tool's moderate complexity (list operation with filters), no annotations, and no output schema, the description is minimally adequate. It states what the tool does but lacks details on behavior, output format, or error handling. For a tool with 3 parameters and no structured safety hints, it should provide more context to be 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 100%, meaning the input schema already documents all three parameters (site, post, status) with clear descriptions. The description adds no additional meaning beyond implying filtering exists, which is already covered by the schema. Baseline 3 is appropriate when the schema does the heavy lifting, but no extra value is added.

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

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

The description clearly states the verb ('Lists') and resource ('comments from a WordPress site'), and specifies the action includes filters. It distinguishes itself from siblings like wp_get_comment (which retrieves a single comment) and wp_create_comment (which creates comments). However, it doesn't explicitly differentiate from wp_approve_comment or wp_spam_comment, which are also comment-related but perform different actions.

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 through 'with filters,' suggesting it's for retrieving multiple comments with optional filtering. However, it lacks explicit guidance on when to use this tool versus alternatives like wp_get_comment (for single comments) or wp_search_site (for broader searches). No exclusions or prerequisites are mentioned, leaving usage somewhat open-ended.

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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions filtering but doesn't specify pagination behavior (e.g., default page, total count), rate limits, authentication requirements, or error handling. For a list operation with potential complexity, this leaves significant gaps in understanding how the tool behaves beyond basic functionality.

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 ('Lists media items from a WordPress site') and adds a key feature ('with filters') without any wasted words. It's appropriately sized for a straightforward list tool, making it easy to parse quickly.

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

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

Given the tool's moderate complexity (list operation with 4 optional parameters) and lack of annotations and output schema, the description is minimally adequate. It covers the basic purpose but misses details like return format (e.g., array of objects, pagination metadata), error cases, or performance considerations, which would be helpful for an agent to use it effectively.

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

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

Schema description coverage is 100%, so the schema fully documents all four parameters (site, per_page, search, media_type). The description adds no additional meaning beyond 'with filters,' which is already implied by the parameter names. This meets the baseline of 3, as the schema does the heavy lifting, but the description doesn't enhance parameter understanding.

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

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

The description clearly states the verb ('Lists') and resource ('media items from a WordPress site'), making the purpose unambiguous. It distinguishes itself from sibling tools like wp_get_media (which likely retrieves a single item) and wp_delete_media by focusing on listing with filtering. However, it doesn't explicitly differentiate from wp_search_site, which might overlap in search functionality.

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 through 'with filters,' suggesting it's for retrieving multiple media items with optional filtering, but provides no explicit guidance on when to use this versus alternatives like wp_get_media (for single items) or wp_search_site (for broader site searches). No when-not-to-use scenarios or prerequisites are mentioned, leaving usage context partially inferred.

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?

With no annotations provided, the description carries the full burden of behavioral disclosure. While 'Lists' implies a read-only operation, the description doesn't mention important behavioral aspects like pagination behavior (implied by 'per_page' parameter but not explained), authentication requirements, rate limits, or what happens when filters return no results. For a tool with 4 parameters and no annotation coverage, this is insufficient.

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

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

The description is a single, efficient sentence that communicates the core functionality without waste. It's appropriately sized for a listing tool and front-loads the essential information. Every word earns its place in this compact description.

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

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

Given the tool's moderate complexity (4 parameters, no output schema, no annotations), the description is adequate but has clear gaps. It covers the basic purpose but lacks behavioral context and usage guidance. The 100% schema coverage helps compensate, but for a listing tool that likely returns structured data, more context about the return format would be helpful since there's 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 schema description coverage is 100%, meaning all parameters are well-documented in the input schema itself. The description adds minimal value beyond the schema by mentioning 'with filters' which aligns with the search and status parameters. However, it doesn't provide additional context about parameter interactions or usage patterns that aren't already in the schema descriptions.

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

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

The description clearly states the verb ('Lists') and resource ('pages from a WordPress site'), making the purpose immediately understandable. It also mentions 'with filters' which adds specificity about functionality. However, it doesn't explicitly differentiate from sibling tools like wp_list_posts or wp_list_media, which would require 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. There are multiple listing tools in the sibling set (wp_list_categories, wp_list_comments, wp_list_media, wp_list_posts, wp_list_tags, wp_list_users), but the description doesn't help an agent choose between them. No context about prerequisites or exclusions is provided.

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

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

With no annotations provided, the description carries the full behavioral burden. 'Lists' implies a non-destructive read and the examples reveal pagination (--per_page/--page), but defaults (page size, sort order), rate limits, and required permissions are unstated. 'Enhanced metadata display' is an unexplained trait that adds little actionable information.

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

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

The leading sentence front-loads purpose and scope, and the examples are terse and scannable. Six example lines is slightly more inventory than needed for a single-parameter tool, but nothing is padded prose.

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 list tool with no output schema, the description should at minimum convey result shape and pagination defaults; it conveys neither, and it describes filter parameters the schema does not expose. The description is serviceable but leaves an agent with an incomplete and partially inconsistent picture of the call surface.

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

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

Schema coverage is 100% for the single exposed parameter (site), so the baseline is 3. The risk here is the opposite of a gap: the examples advertise --search, --status, --categories, --per_page and --page flags that do not appear anywhere in the input schema, which could lead an agent to pass parameters the schema rejects.

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?

States a specific verb and resource ('Lists posts from a WordPress site') and enumerates the filtering dimensions (search, status, category/tag). It never names the sibling it is contrasted with (e.g., wp_get_post for a single post, wp_list_pages for pages), so an agent must infer the boundary from the resource name alone.

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 six usage examples clearly show how to invoke the tool for search, status, category and pagination cases, which is genuinely useful. However, there is no statement of when to prefer this tool over wp_search_site, wp_get_post, or wp_list_pages, and no prerequisites (auth, site configuration) 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?

With no annotations provided, the description carries full burden but offers minimal behavioral insight. It states it 'lists' tags but doesn't describe return format (e.g., array of objects with id/name), pagination behavior, authentication requirements, rate limits, or error conditions. This is inadequate for a tool with zero annotation coverage.

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

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

The description is a single, efficient sentence with zero wasted words. It's appropriately sized for a simple list operation and front-loads the core purpose immediately.

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 operation with no annotations and no output schema, the description is insufficient. It doesn't explain what data is returned, how results are formatted, or any behavioral constraints. While the schema covers inputs well, the overall context for agent usage is 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 100%, so the schema fully documents both parameters (site and search). The description adds no parameter-specific information beyond what's in the schema, meeting the baseline expectation when schema does the heavy lifting.

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

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

The description clearly states the verb ('Lists') and resource ('tags from a WordPress site'), making the purpose immediately understandable. It doesn't explicitly distinguish from sibling tools like 'wp_list_categories' or 'wp_list_posts', but the resource specificity is adequate for basic understanding.

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. There's no mention of sibling list tools (e.g., wp_list_categories, wp_list_posts) or search tools (e.g., wp_search_site), nor any context about prerequisites or typical use cases.

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?

With no annotations provided, the description carries full burden but only states it 'lists users with comprehensive filtering and detailed information.' It doesn't disclose behavioral traits like whether this is a read-only operation (implied but not stated), pagination behavior, rate limits, authentication requirements, or what happens with large result sets. For a list tool with no annotations, this is insufficient.

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

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

The description is appropriately sized and front-loaded: the first sentence clearly states the purpose, followed by well-organized usage examples that demonstrate practical applications. Every sentence earns its place by illustrating different parameter combinations.

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 3 parameters with 100% schema coverage but no annotations and no output schema, the description is adequate for basic usage but incomplete. It doesn't address what the return format looks like (list structure, fields included), pagination, error conditions, or performance considerations for a list operation that could return many users.

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

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

Schema description coverage is 100%, so the schema already fully documents all 3 parameters. The description adds minimal value beyond what's in the schema - it mentions filtering capabilities generally and provides usage examples that illustrate parameter combinations, but doesn't add semantic meaning beyond the schema's parameter descriptions.

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

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

The description clearly states the tool's purpose with specific verb ('Lists') and resource ('users from a WordPress site'), plus it distinguishes from siblings by specifying 'comprehensive filtering and detailed user information' which differentiates it from wp_get_user (singular) and wp_search_site (broader search).

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 through usage examples showing when to use the tool (searching, filtering by role, combined queries), but doesn't explicitly state when NOT to use it or mention alternatives like wp_search_site for broader searches or wp_get_user for single user retrieval.

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 provided, so the description carries the full burden of behavioral disclosure. While 'Get' implies a read-only operation, the description doesn't specify whether this requires authentication, has rate limits, returns paginated results, or what format the output takes. For a tool with 5 parameters and no output schema, this lack of behavioral context is a significant gap.

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

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

The description is extremely concise—a single sentence with no wasted words. It's front-loaded with the core purpose ('Get performance alerts and anomaly detection results'), making it easy to parse. Every word earns its place, and there's no redundancy or 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?

Given the tool's complexity (5 parameters, no output schema, no annotations), the description is incomplete. It doesn't address what the tool returns, how results are structured, or any behavioral traits like error handling. For a data retrieval tool with filtering options, more context is needed to help the agent understand the output and usage nuances.

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

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

The input schema has 100% description coverage, so all parameters are documented in the schema itself. The description doesn't add any meaning beyond what's in the schema—it doesn't explain parameter interactions, default behaviors, or provide examples. With high schema coverage, the baseline score of 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states the tool's purpose: 'Get performance alerts and anomaly detection results'. It specifies the verb ('Get') and resource ('performance alerts and anomaly detection results'), making the function unambiguous. However, it doesn't distinguish this tool from its sibling performance tools like 'wp_performance_stats' or 'wp_performance_history', which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. With multiple sibling tools related to performance (e.g., 'wp_performance_stats', 'wp_performance_history'), there's no indication of whether this tool is for real-time alerts, historical data, or specific use cases. The absence of any context or exclusions leaves the agent without usage direction.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool compares performance against benchmarks but doesn't describe what data is compared, how benchmarks are sourced, whether it's a read-only operation, potential rate limits, or the format of results. For a tool with zero annotation coverage, this is a significant gap in transparency.

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

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

The description is a single, clear sentence: 'Compare current performance against industry benchmarks.' It is front-loaded with the core purpose, has zero wasted words, and is appropriately sized for the tool's complexity. Every word earns its place by conveying essential information 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?

Given the tool's moderate complexity (3 parameters, no output schema, no annotations), the description is minimally adequate. It states the purpose but lacks details on behavior, usage context, or result format. With schema coverage at 100%, parameters are documented, but the description doesn't compensate for missing annotations or output schema, leaving gaps in overall completeness.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters (site, category, includeRecommendations) with descriptions. The tool description adds no additional meaning beyond the schema, such as explaining the significance of categories or how recommendations are generated. Baseline 3 is appropriate when the schema handles parameter documentation effectively.

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

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

The description clearly states the tool's purpose: 'Compare current performance against industry benchmarks.' It specifies the verb 'compare' and the resource 'current performance' against 'industry benchmarks.' However, it doesn't explicitly differentiate from sibling tools like wp_performance_stats or wp_performance_history, which might also involve performance data but serve different functions.

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 doesn't mention prerequisites, context for benchmarking, or how it differs from sibling tools such as wp_performance_stats (which might show stats without comparison) or wp_performance_optimize (which might suggest improvements). This lack of comparative context leaves usage ambiguous.

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?

With no annotations provided, the description carries full burden for behavioral disclosure. 'Export' implies data retrieval rather than mutation, but the description doesn't specify whether this is a read-only operation, what permissions are required, whether it's resource-intensive, or what the output looks like (file download, data stream, etc.). For a performance export tool with 5 parameters and no annotation coverage, this leaves significant behavioral questions unanswered.

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

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

The description is extremely concise at just 3 words, with zero wasted language. It's front-loaded with the core action and resource, making it immediately understandable. Every word ('Export', 'comprehensive', 'performance report') contributes essential meaning without redundancy or 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?

Given the tool's complexity (5 parameters, performance domain) and absence of both annotations and output schema, the description is insufficient. It doesn't explain what a 'comprehensive performance report' contains, how it differs from simpler performance tools, what format the export takes, or what happens after invocation. For a data export tool with multiple configuration options, users need more context about the output and behavioral characteristics.

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

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

The description adds no parameter-specific information beyond what's already in the schema, which has 100% coverage. While the schema thoroughly documents all 5 parameters with descriptions, enums (implied for format and timeRange), and defaults, the description doesn't provide additional context about parameter interactions, typical combinations, or semantic meaning beyond the schema. This meets the baseline for high schema coverage but doesn't add value.

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

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

The description 'Export comprehensive performance report' clearly states the action (export) and resource (performance report), with 'comprehensive' providing some scope indication. It distinguishes from siblings like wp_performance_stats or wp_performance_history by focusing on export rather than retrieval or monitoring. However, it doesn't explicitly differentiate from wp_performance_benchmark or wp_performance_alerts, which could also involve performance data.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to choose this export tool over wp_performance_stats for quick metrics, wp_performance_history for trend data, or wp_performance_benchmark for comparative analysis. There's no context about prerequisites, timing considerations, or typical use cases for exporting performance reports.

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 provided, so the description carries full burden. 'Get historical performance data and trends' implies a read-only operation but doesn't disclose important behavioral traits: whether authentication is required, rate limits, data freshness, format of returned data (e.g., time-series), or what 'trends' specifically entails. For a tool with 4 parameters and no output schema, this leaves significant gaps.

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

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

The description is a single, efficient sentence: 'Get historical performance data and trends.' It's front-loaded with the core purpose, has zero wasted words, and appropriately sized for a tool with clear parameters documented elsewhere.

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

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

Given 4 parameters, no annotations, and no output schema, the description is incomplete. It doesn't explain what 'historical performance data' includes (e.g., aggregated metrics, raw logs), how trends are calculated, or the format of returned data. For a tool that likely returns complex time-series data, this leaves the agent guessing about output structure 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 100%, so the schema already documents all 4 parameters thoroughly with descriptions and constraints (e.g., timeframe options, metrics list). The description adds no additional parameter semantics beyond what's in the schema, maintaining the baseline score of 3 where the schema does the heavy lifting.

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

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

The description clearly states the tool's purpose: 'Get historical performance data and trends' specifies the verb ('Get') and resource ('historical performance data and trends'). It distinguishes from most sibling tools (which are CRUD operations for content, users, etc.) but doesn't explicitly differentiate from other performance-related siblings like wp_performance_stats or wp_performance_alerts.

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 doesn't mention sibling tools like wp_performance_stats (which might provide current stats) or wp_performance_alerts (which might focus on alert conditions), nor does it specify prerequisites or appropriate contexts for retrieving historical data versus other performance metrics.

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 provided, so the description carries full burden. 'Get' implies a read-only operation, but it doesn't disclose whether this requires specific permissions, has rate limits, or what the output format looks like (e.g., list of recommendations, structured data). The description lacks behavioral context beyond the basic action.

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

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

The description is a single, efficient sentence with no wasted words. It's appropriately sized for a tool with good schema coverage, though it could be more front-loaded with specific context (e.g., 'WordPress performance optimization recommendations').

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 5 parameters, no annotations, and no output schema, the description is inadequate. It doesn't explain what the tool returns (e.g., list of actionable items, scores, predictions) or how results are structured. Given the complexity and lack of structured data, more behavioral and output context is needed.

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

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

Schema description coverage is 100%, so the schema already documents all 5 parameters thoroughly. The description adds no additional meaning about parameters beyond what's in the schema (e.g., it doesn't explain how 'focus' values affect recommendations or what 'includeROI' entails). Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description 'Get optimization recommendations and insights' states the general purpose (retrieving recommendations) but is vague about scope and resource. It doesn't specify what type of optimization (WordPress performance) or distinguish from sibling tools like wp_performance_stats or wp_performance_benchmark, which could also provide performance-related data.

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

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

No explicit guidance on when to use this tool versus alternatives. While the description implies it's for optimization recommendations, it doesn't specify when to choose this over wp_performance_stats (which might show metrics) or wp_performance_alerts (which might identify issues). No prerequisites or exclusions are mentioned.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. While 'Get' implies a read operation, it doesn't specify whether this requires authentication, has rate limits, returns real-time versus cached data, or what format the statistics come in. The description is too minimal for a tool that presumably accesses system metrics.

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

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

The description is extremely concise at just 6 words, with no wasted language. It's front-loaded with the core purpose and doesn't include any unnecessary elaboration 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 performance statistics tool with no annotations and no output schema, the description is insufficient. It doesn't explain what types of statistics are returned, whether the data is real-time or historical, what authentication is required, or how this differs from other performance tools. The minimal description leaves too many contextual 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 description coverage is 100%, so the schema already documents all three parameters thoroughly. The description adds no additional parameter information beyond what's in the schema, which meets the baseline expectation when schema coverage is complete.

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

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

The description clearly states the tool's purpose with a specific verb ('Get') and resource ('real-time performance statistics and metrics'), making it easy to understand what the tool does. However, it doesn't explicitly differentiate itself from sibling performance tools like wp_performance_alerts, wp_performance_benchmark, or wp_performance_history, which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. With multiple sibling performance tools available (performance_alerts, benchmark, export, history, optimize), there's no indication of what distinguishes this statistics tool from those others or when each should be selected.

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 provided, so the description carries the full burden. It mentions 'comprehensive results and metadata,' which hints at output behavior, but fails to disclose critical traits like whether this is a read-only operation, potential rate limits, authentication needs, or error handling. For a search tool with zero annotation coverage, this leaves significant gaps in behavioral understanding.

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

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

The description is well-structured with a clear purpose statement followed by usage examples. It's appropriately sized and front-loaded, though the examples could be more concise. Every sentence serves a purpose, but there's slight redundancy in the examples that could be trimmed.

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

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

Given the tool's moderate complexity (search with 3 parameters), no annotations, and no output schema, the description is partially complete. It covers the basic purpose and usage but lacks details on output format, error cases, or performance considerations. It's adequate for a simple search tool but could be more comprehensive.

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

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

Schema description coverage is 100%, so the schema already documents all parameters (site, term, type) with clear descriptions. The description adds minimal value beyond the schema, as it only reiterates parameter usage in examples without providing additional syntax or format details. This meets the baseline for high schema coverage.

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

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

The description clearly states the tool performs 'site-wide search for content across posts, pages, and media with comprehensive results and metadata,' which specifies the verb (search) and resources (posts, pages, media). It distinguishes itself from sibling tools like wp_list_posts or wp_list_pages by focusing on search functionality rather than listing, though it doesn't explicitly contrast with all siblings.

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

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

The description includes usage examples that imply when to use this tool (e.g., for searching posts, pages, or media), but it lacks explicit guidance on when to choose this over alternatives like wp_list_posts or wp_seo_keyword_research. The examples provide context but no clear 'when-not' or alternative tool recommendations.

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

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

No annotations are provided, so the description carries the full burden. It implies a read-only analysis but never states that nothing is modified, whether authentication or SEO plugin integration is required, or whether the operation is rate-limited or expensive across a whole site.

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 no filler, and the analyzed dimensions are listed compactly. It is appropriately sized, though it stops short of being information-dense enough for a 5.

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 no annotations, the description should explain what the analysis returns and, critically, how the content to analyze is identified — the sole parameter is a site ID, not a post ID, leaving it ambiguous whether it scans a single post, a set of posts, or the whole site. That ambiguity is a real obstacle to 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?

Only one parameter exists and schema description coverage is 100%, so the schema already documents the site ID fully. The description adds nothing about how the target content is selected, which is the real semantic gap. Baseline 3 applies when the schema does the heavy lifting.

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

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

States a specific verb (Analyze) and resource (WordPress post content) and enumerates the analysis dimensions (readability, keyword density, structure, technical factors). This distinguishes it from the generation-oriented siblings like wp_seo_generate_metadata, but the description never names those siblings or explicitly contrasts itself with them.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as wp_seo_site_audit or wp_seo_generate_metadata. The agent must infer from the name alone that this is the diagnostic step rather than the fix step.

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 provided, so the description carries the full burden. It mentions progress tracking and error handling, which are useful behavioral hints, but doesn't disclose permissions required, whether updates are reversible, rate limits, or the return format. For a bulk mutation tool with zero annotation coverage, this is a significant gap.

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

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 includes key behavioral traits without any waste.

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 is a bulk mutation operation for SEO metadata, the description is incomplete. It lacks essential details such as required permissions, what metadata fields can be updated, how to specify the posts, and what the progress tracking and error handling entail. No output schema exists to compensate.

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

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

Schema coverage is 100%, so the single parameter (site) is fully documented in the schema. The description adds no parameter-specific information, which is acceptable when the schema already covers it. Baseline 3 is appropriate.

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

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

The description states a specific verb (Update) and resource (SEO metadata) with scope (multiple posts). It's clear what the tool does, though it doesn't explicitly distinguish itself from siblings like wp_seo_generate_metadata or wp_update_post.

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 when-to-use guidance or alternatives are mentioned. The agent must infer that this is for bulk updates rather than single-post updates, and there's no indication of how it differs from wp_seo_generate_metadata or wp_update_post.

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 provided, so the description carries the full behavioral burden. It does not disclose whether generated metadata is persisted to the site, whether it overwrites existing metadata, what permissions are required, or what the return value looks like. 'Generate' is ambiguous: it could return suggestions or mutate stored content.

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 with zero filler, and the core capability is front-loaded. It does not bury the action or include redundant restatements.

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

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

Given that there are no annotations, no output schema, and a complex sibling landscape, the description is too thin. It lacks usage context, behavioral disclosure, and any routing information against similarly named SEO tools, leaving the agent under-informed 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?

The single parameter 'site' has 100% schema description coverage, so the schema itself explains its purpose and conditional requirement. The description adds no parameter meaning beyond the schema, which yields a baseline score of 3 when schema coverage is high.

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 and resource ('Generate SEO-optimized metadata') and lists the produced artifacts (title tags, meta descriptions, OpenGraph, Twitter Card data). However, it does not distinguish itself from the sibling tool wp_seo_bulk_update_metadata, leaving ambiguity about when each applies.

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 such as wp_seo_bulk_update_metadata, wp_seo_analyze_content, or wp_seo_site_audit. The description provides only a static capability statement with no contextual triggers 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?

No annotations are provided, so the description carries the full behavioral burden. It does not say whether the generated schema is persisted to the site or merely returned, whether an SEO plugin/API key is required, or whether generation depends on existing content, all of which matter for a tool whose name contains 'generate'.

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 no filler. It is efficient, though its brevity is partly the source of the gaps elsewhere.

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

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

For a one-parameter tool with no output schema and no annotations, the description is minimally adequate but incomplete: it never clarifies the return value (JSON-LD payload vs. confirmation of a write) or the dependency on a configured SEO plugin. This is the main ambiguity an agent would face.

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

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

Schema coverage is 100% and the single 'site' parameter is fully documented in the schema, including its config-file origin and multi-site requirement. The description adds nothing about parameters, which is acceptable here since the schema does the work.

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 pairs a specific verb ('Generate') with a specific artifact ('JSON-LD structured data schema') and states the outcome ('enhanced search results'). It stops short of distinguishing this tool from siblings like wp_seo_validate_schema or wp_seo_generate_metadata, so the boundary between generating and validating schema is left to inference.

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