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

With no annotations, the description carries the full burden of behavioral disclosure. It only says 'Activate a plugin' without detailing whether it requires specific permissions, changes the database, or what happens if the plugin is already active. This is insufficient for an action-oriented tool.

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

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

The description is a single sentence, which is concise but overly minimal. It is front-loaded, but it does not earn its place by providing enough information. Adding a bit more context (e.g., input format) would improve without sacrificing 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 simple tool but lack of output schema and annotations, the description is incomplete. It does not address what happens when the plugin is already active, or if the plugin slug is invalid. For a tool that modifies state, more context on behavior is expected.

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

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

The input schema has 0% description coverage, and the description does not explain the 'plugin' parameter. It fails to indicate whether it expects a slug, a file name, or a full path. This leaves the agent guessing about the correct input format.

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

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

The description clearly states the action 'Activate a plugin' with a specific verb and resource. It distinguishes itself from the sibling 'wordpress_deactivate_plugin' by indicating activation vs deactivation. However, it does not specify what 'plugin' means exactly (e.g., slug or file name), which could cause ambiguity.

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 compared to alternatives like 'wordpress_plugin_exists' to check if a plugin exists before activation, or 'wordpress_get_plugins' to list available plugins. There is no discussion of prerequisites, side effects, or scenarios where activation is 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 provided, so description carries full burden. It only states activation without any details on error handling, state changes, or side effects. The behavioral information is minimal.

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

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

Extremely concise at one sentence. The essential purpose is front-loaded, but it lacks parameter explanation for completeness.

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

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

For a simple tool with one parameter and no output schema, the description conveys basic purpose but lacks behavioral transparency and parameter semantics, leaving it incomplete for confident 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 has 0% description coverage, and the tool description does not explain the 'stylesheet' parameter. It adds no meaning beyond the schema, failing to compensate for the lack of 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 it activates a theme ('switch to it as the active theme'), with a specific verb and resource. It distinguishes from sibling tools like wordpress_delete_theme or wordpress_get_themes.

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 vs alternatives. It is implied by the name that this is for changing the active theme, but 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?

No annotations provided, and description is minimal. Does not disclose if it overwrites capabilities, requires admin access, or handles errors for invalid roles.

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

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

Single sentence is concise but too terse. Lacks structure to convey needed information effectively.

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 no output schema and sparse annotations, description fails to explain return values, side effects, or typical usage patterns for a mutation tool.

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

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

Schema has 0% description coverage; description adds no extra meaning beyond parameter names. No explanation of expected values (e.g., role slug, capability format).

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

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

Description clearly states the action (add) and the resource (capability) and target (user role). It distinguishes from sibling tools like wordpress_remove_capability and wordpress_check_user_capability.

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

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

No guidance on when to use this tool vs. alternatives like create_role or check_user_capability. No prerequisites or context 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?

Without annotations, the description bears full responsibility for behavioral disclosure. It states 'analyze,' implying read-only, but does not confirm that the tool does not modify data, explain required permissions, or describe the output format. This leaves the agent with uncertainty about side effects and results.

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 could be slightly more informative without adding length (e.g., specifying the type of analysis), but it is not verbose.

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

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

For a simple tool with one parameter and no output schema, the description provides minimal context. It differentiates from siblings via the verb 'analyze,' but does not explain what the analysis output contains or how to interpret it. Given the many sibling tools, more detail on the analysis scope would improve completeness.

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

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

Input schema coverage is 0%, so the description should add meaning to the parameter 'postId.' However, the description does not mention 'postId' at all. Although the parameter name is self-explanatory, the description provides no additional context beyond the schema, resulting in baseline 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 'Analyze SEO elements for a post' clearly states the action (analyze) and resource (SEO elements for a post), distinguishing it from sibling tools that get, set, or delete. However, it does not specify which SEO elements are analyzed (e.g., meta tags, keywords, readability), leaving some ambiguity.

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 wordpress_get_post (which might return SEO data) or wordpress_set_seo_meta (for modification). An agent must infer usage 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?

With no annotations, the description must fully convey behavioral traits, but it only states the action. It fails to disclose whether the assignment overwrites existing assignments, requires specific capabilities, or validates the existence of the given location or menu ID. This lack of detail hinders an agent's ability to anticipate side effects.

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

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

The description is a single concise sentence that directly states the tool's purpose. While it could benefit from additional structure (e.g., listing parameter roles), it is appropriately short for a simple operation and contains no filler.

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

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

Given the tool's simplicity and lack of output schema, the description still omits critical context: what identifies a theme location, where to obtain the location value, and any side effects of reassignment. An agent cannot confidently use this tool based solely on the description, as it lacks essential operational details.

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

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

The input schema defines two parameters (location, menuId) with only types, and the description adds no explanation of what valid values are (e.g., location slug vs. name, expected format for menuId). With 0% schema description coverage, the description does not compensate, leaving the agent to guess parameter semantics.

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

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

The description clearly states the action ('assign') and the resources involved ('menu to a theme location'), distinguishing it from sibling tools like wordpress_create_menu (creates new menus) or wordpress_get_menu_locations (retrieves locations). It is specific and unambiguous.

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

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

No guidance is provided on when to use this tool over alternatives, such as when creating a new menu first or retrieving existing locations. It does not mention prerequisites or how to handle cases where a menu is already assigned to a location.

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, the description bears full responsibility for behavioral disclosure. Only states 'assign' implying mutation, but does not disclose if previous roles are replaced, if role existence is validated, or what permissions are required. This is insufficient for a mutation tool.

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

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

Single sentence is concise and front-loaded, but lacks important details. Could be improved by adding a brief note on expected role format or result without becoming verbose.

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

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

Given no annotations, output schema, or parameter descriptions, the description is too minimal. For a simple assignment tool, the agent needs to know confirmation behavior or error conditions. Incomplete for reliable invocation.

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

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

Schema coverage is 0%, so description must compensate. However, it adds no meaning beyond the parameter names. Does not explain what values 'role' accepts (e.g., slug, name) or how 'userId' is specified. Agent must infer from context.

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

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

The description clearly states the action 'Assign role to user', which is a specific verb-resource combination. It distinguishes from siblings like 'add_capability' or 'create_role' by focusing on role assignment. However, it does not explicitly differentiate from 'update_user' which might also modify roles.

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

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

No guidance on when to use this tool vs alternatives such as 'update_user' or 'add_capability'. The description lacks any context about prerequisites, typical 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?

No annotations are provided, and the description fails to disclose behaviors such as whether a file is created, its naming convention, or any side effects. The agent is left without knowing what happens after invocation.

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

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

The description is extremely concise (three words) and front-loaded. While brevity is good, it omits potentially important context for an AI agent, but for a parameterless tool it is reasonably efficient.

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

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

Given the tool's simplicity (no parameters, no output schema), the minimal description may be sufficient for a basic understanding. However, it lacks details on what the export produces or how to use the output, leaving gaps in completeness.

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

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

There are no parameters in the input schema, so the description adds minimal additional meaning. Per the guidelines, 0 parameters leads to a baseline of 4, and the description correctly indicates the action without needing to document parameters.

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

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

The description 'Export database only' clearly states the action (export) and resource (database). It distinguishes from sibling tools like wordpress_backup_files and wordpress_full_backup by focusing solely on the database. However, it lacks specificity about the output format or location.

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

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

The description provides no guidance on when to use this tool versus alternatives such as wordpress_full_backup or wordpress_backup_files. There is no mention of when to prefer this tool over others.

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

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

No annotations are provided. The description indicates a mutation (backup creation) but does not disclose specifics like storage location, duration, or overwrite behavior. It is adequate for a simple tool.

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 (4 words) and front-loaded with the key differentiator. 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 no parameters and no output schema, the description is minimally complete. It could mention the output/result, but is sufficient for a zero-param tool.

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

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

The tool has no parameters, so the schema covers all. No need for parameter details in description. Baseline 4 applies.

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

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

The description 'Backup files only (no database)' clearly states the tool's function: backing up files, not the database. It distinguishes from siblings like wordpress_backup_database and wordpress_full_backup.

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

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

The phrase 'no database' implicitly guides when to use this tool versus alternatives. However, it does not explicitly state when to use it or mention alternatives.

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

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

The description indicates a write operation but offers no details on batch limits, error handling, partial failures, or any other behavioral aspects. With no annotations provided, the description should cover these but fails to do so.

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

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

The description is brief but lacks necessary detail. It front-loads the action but does not include sufficient information to be useful, making it more underspecified than concise.

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

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

Given the lack of output schema, parameter descriptions, and annotations, the description is severely incomplete. The agent cannot determine the required data format or expected behavior, making the tool nearly unusable.

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 'posts' is an array with no schema description coverage. The description does not explain the required structure of each post (e.g., title, content, fields), leaving the agent unable to construct valid input.

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

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

The description clearly states the tool creates multiple posts in one operation, distinguishing it from single post creation tools like wordpress_create_post. However, it does not specify whether these are standard WordPress posts or if custom post types are supported.

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

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

The description mentions efficiency but provides no explicit guidance on when to use this tool versus alternatives like wordpress_create_post or wordpress_import_content. No conditions or exclusions are stated.

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

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

Annotations are missing, so the description carries full burden. It only says 'Delete', implying a destructive operation, but does not disclose permanence, side effects (e.g., post attachments), error handling, or whether it requires authentication.

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?

At 4 words, the description is very concise but lacks structure and essential details. It does not front-load critical information; instead, it omits almost everything, making it insufficient for an agent to use correctly.

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 destructive nature of bulk deletion, no output schema, and no annotations, the description is severely incomplete. It does not explain parameters, return values, reversibility, or any behavioral context, leaving a dangerous gap.

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

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

The single parameter 'mediaIds' has no schema description (0% coverage). The tool description does not explain what mediaIds expects (e.g., array of numeric IDs, post IDs for attachments), leaving the agent without necessary meaning.

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 'Delete multiple media files' clearly states a specific verb (Delete) and resource (media files), and the 'multiple' distinguishes it from the sibling wordpress_delete_media (singular). However, it lacks nuance like whether deletion is permanent or to trash.

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 like wordpress_delete_media or wordpress_bulk_optimize_images. The description does not mention prerequisites, context, or when not to use it.

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

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

No annotations exist, so the description carries full burden. It only states 'delete' without disclosing whether the operation is permanent, what the 'force' parameter does (e.g., bypass trash), or any side effects. This is critically insufficient for a data-mutating tool.

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 short sentence, which is concise but under-specified. It lacks structure for an operation with required parameters and behavioral implications, resulting in unhelpful brevity.

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

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

Given no annotations, no output schema, and two parameters with zero coverage, the description is highly incomplete. It fails to convey critical aspects like the effect of 'force', whether posts go to trash or are permanently deleted, or any confirmation 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 input schema has 0% description coverage for parameters, and the tool description adds nothing about 'postIds' or 'force'. The agent receives no guidance on the meaning or expected values of these parameters beyond the schema types.

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

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

The description clearly states the action ('Delete multiple posts') and resource ('posts'), with 'one operation' indicating batch processing. It distinguishes from single-deletion siblings (wordpress_delete_post) and bulk media deletion (wordpress_bulk_delete_media). However, it adds little beyond the tool name, which already conveys 'bulk delete posts'.

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 use for batch deletion of posts but provides no explicit guidance on when to choose this over single deletion or media deletion. No alternatives or when-not conditions are mentioned, relying on the agent to infer from the name and siblings.

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

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

With no annotations, the description must disclose behavioral traits. It states 'compress all images' implying a write/mutation operation, but does not explain whether it creates backups, whether the operation is reversible, or if it runs asynchronously. The tool's impact on image quality, disk usage, or performance is also unaddressed.

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: 'Bulk optimize images (compress all images)'. It is tightly focused, contains no fluff, and front-loads the core action. Every word earns its place, achieving maximum 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 zero parameters and no output schema, the description is minimally adequate but leaves ambiguity about the scope: 'all images' could mean all images in the media library, all image sizes, or all images on the site. It also does not confirm success indicators or potential side effects. A more complete description would specify the exact scope and typical effect.

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

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

The input schema has zero parameters, so schema description coverage is effectively 100%. Since there are no parameters to document, the description does not need to add parameter details. The baseline of 4 is appropriate, as the description does not mislead but adds no extra value beyond the schema.

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

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

The description clearly states 'Bulk optimize images (compress all images)', specifying the action (optimize/compress) and resource (images). It is distinguishable from sibling tools like wordpress_convert_to_webp, which converts images to WebP format, and wordpress_regenerate_thumbnails, which regenerates thumbnail sizes. This covers the core purpose unambiguously.

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 wordpress_convert_to_webp or wordpress_regenerate_thumbnails. It does not specify prerequisites, typical use cases, or scenarios to avoid. The absence of context leaves the agent to infer usage 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. The description only says 'Update' which implies mutation. It does not disclose permissions, reversibility, or what gets updated beyond the name, leaving 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 sentence but omits critical details. It is under-specified rather than concise, failing to provide necessary information for an agent to use the tool correctly.

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

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

No output schema is present, and the description does not mention return values. With one parameter lacking schema detail and no behavioral details, the description is severely incomplete for a batch mutation tool.

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

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

Input schema has one parameter 'updates' (type array) with 0% schema description coverage. The description adds no meaning about what the array should contain, how to structure updates, or constraints.

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

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

The description explicitly states 'Update multiple posts in one operation', clearly indicating the action and resource. It distinguishes from sibling 'wordpress_update_post' which handles single updates.

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 'efficient for batch modifications', implying use for updating multiple posts. While it doesn't explicitly state when not to use or mention alternatives like 'wordpress_update_post', the context with siblings makes it clear.

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

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

No annotations provided, so description carries full burden. It does not disclose that this is a read-only operation, nor does it mention network access requirements or potential side effects. The agent cannot infer behavioral traits beyond the obvious.

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

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

Single sentence, no extraneous words. Front-loaded with core purpose. 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?

Tool has no parameters or output schema. Description is minimal: it identifies inputs and purpose but omits return value semantics (e.g., format of updates list). Adequate for a trivial tool, but a more complete description would describe 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?

No parameters exist, and schema coverage is 100%. Description adds no parameter information, but none is needed. Baseline of 3 adjusted upward because the absence of parameters is self-evident and no further clarification required.

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

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

Description explicitly states it checks for available updates in three categories (WordPress, plugins, themes). This clearly distinguishes it from sibling tools like 'wordpress_get_version_info' which reports current versions rather than available updates.

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?

Implied usage: to check for pending updates. But no guidance on when to use this versus alternatives like 'wordpress_get_plugins' or 'wordpress_get_themes' which might also provide update context. No exclusions or prerequisites 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?

No annotations are present, so the description must communicate behavioral traits. However, it only states 'Check if user has specific capability' without disclosing return type (likely boolean), error handling (e.g., user not found), or that it is read-only. The agent lacks critical behavioral 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 description is a single sentence, which is concise. However, it is too brief and lacks detail. While it saves words, it does not earn its place by providing sufficient value. A slightly longer description with key details would be more useful.

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 no output schema and the need for return value disclosure, the description is incomplete. The agent cannot determine what the tool returns (e.g., boolean, string). Additionally, the tool lacks context among many similar sibling tools. The description fails to fully equip the agent 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 input schema has 0% description coverage, meaning no parameter descriptions are provided. The tool's description also adds no explanation beyond the parameter names 'userId' and 'capability', which are self-explanatory but insufficient. The agent would benefit from knowing expected formats or constraints.

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

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

The description 'Check if user has specific capability' clearly indicates the verb (check) and resource (user capability). It distinguishes from sibling tools like add_capability, remove_capability, and get_capabilities by implying a single capability check, though it doesn't explicitly differentiate from get_capabilities which lists all. Still, the purpose is clear.

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

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

No usage guidance is provided. The description does not indicate when to use this tool versus alternatives like wordpress_get_capabilities for listing all capabilities, or wordpress_add_capability for modifying. Without such context, the agent may misuse the tool.

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

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

No annotations are provided, so the description must fully disclose behavior. It mentions 'clean up' but does not specify that it permanently deletes data, permissions required, or impact on performance. This leaves ambiguity about destructiveness.

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

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

The description is a single sentence that front-loads the core action and lists key items. It is efficient, though could be more structured with separate sentences for guidance.

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

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

Given no output schema and no parameters, the description is brief but lacks completeness on behavioral context (e.g., safety, reversibility). For a destructive operation, more cautionary information is needed.

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

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

The schema has no parameters, so the description provides the only semantic meaning by enumerating the types of data cleaned. This adds value beyond the empty schema.

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

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

The description clearly states the tool 'clean up database' and lists specific items (revisions, auto-drafts, spam, trash), making the purpose distinct from sibling tools like wordpress_optimize_database.

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

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

No guidance on when to use this tool vs alternatives such as wordpress_optimize_database or wordpress_backup_database. No explicit when-to-use or when-not-to-use 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, the description must disclose behavioral traits. It only lists cache types but omits side effects (e.g., performance impact, flushing all caches, required permissions), leaving the agent without crucial operational details.

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

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

The description is a single, efficient sentence of 7 words with no redundancy, front-loading the action and key details. 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 zero parameters, no output schema, and no annotations, the description is minimal. It covers the core function but lacks contextual details like safety, consequences on the site, or when to avoid using it. Adequate for a simple tool but not comprehensive.

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

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

The input schema has zero parameters, so schema coverage is 100%. The description adds no parameter info (none exist) but mentions what caches are cleared, which is valuable context. Baseline 4 for 0 params is appropriate as no additional parameter semantics are needed.

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

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

The description clearly states the action (clear WordPress caches) and specifies the cache types (transients, object cache, page cache), distinguishing it from sibling tools like wordpress_cleanup_database or wordpress_optimize_database.

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, lacks context for typical scenarios (e.g., after plugin updates), and does not mention prerequisites or exclusions.

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

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

No annotations provided, so description must convey behavioral traits. It doesn't state if the tool is destructive (overwrites staging), reversible, or what happens to the staging site. Minimal 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?

Extremely concise (one short sentence) but lacks critical details. Not well-structured for scanning. Could be split into usage and behavior.

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

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

No output schema or annotations. For a potentially destructive operation like cloning, the description is incomplete—missing return values, prerequisites, and safety warnings.

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

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

Schema has one parameter (stagingUrl) with no description and 0% schema coverage. The description does not explain what format or type of URL is expected (e.g., full URL, path, domain only).

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

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

Description states 'Clone WordPress to staging environment' which clearly identifies the action (clone) and target (WordPress to staging). It differentiates from sibling tools like backup/restore, but doesn't specify what is cloned (files, database, both).

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

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

No guidance on when to use this tool vs alternatives. No mention of prerequisites like having a staging environment set up or whether the operation overwrites existing data.

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, and the description does not disclose behavioral traits such as whether the original image is replaced or a new file is created, permission requirements, or potential side effects. The tool's behavior beyond the basic conversion is entirely opaque.

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 (5 words) but is under-specified. It front-loads the purpose but provides no additional value. A truly concise description would pack more information without unnecessary words.

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

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

Given the lack of annotations, output schema, and the presence of related sibling tools, the description is incomplete. It does not explain return values, error handling, or the implications of conversion (e.g., file size reduction, quality loss).

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 sole parameter 'mediaId' is not explained in the description. With 0% schema description coverage, the agent must infer its meaning from the name alone, which is insufficient for correct invocation.

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

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

The description 'Convert image to WebP format' clearly states the action (convert) and the resource (image to WebP). It distinguishes from sibling tools like wordpress_bulk_optimize_images or wordpress_regenerate_thumbnails by specifying WebP conversion. However, it could be more explicit that it operates on WordPress media library images.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites (e.g., server support for WebP), no exclusions, and no comparison to related tools like bulk optimize or regenerate thumbnails.

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, and the description does not disclose behavioral traits such as whether the tool overwrites existing files, requires specific permissions, handles errors, or what side effects occur. The agent has no insight into these critical details.

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

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

The description is very concise (one sentence), but the brevity sacrifices necessary detail. While it is front-loaded with the core action, it does not use its space effectively to provide essential context.

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

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

Given the tool has no output schema, no annotations, and uses two parameters without explanation, the description is notably incomplete. It fails to address return values, error handling, overwrite behavior, or typical usage scenarios, making it insufficient for reliable tool invocation.

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

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

Schema description coverage is 0%, and the description does not explain the 'source' and 'destination' parameters beyond their names. It adds no information about path formats, relative vs absolute paths, allowed directories, or constraints, leaving the agent to guess.

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

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

The description states 'Copy file to another location within WordPress', which clearly specifies the verb ('copy') and resource ('file') and distinguishes it from siblings like 'move' (which deletes source) and other file operations. However, it lacks specificity about the location scope (e.g., within wp-content or anywhere).

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

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

No guidance on when to use this tool versus alternatives like wordpress_move_file or wordpress_delete_file. The description does not provide any context about prerequisites, limitations, or when not to use it.

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

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

Description claims hierarchical support but the input schema only has a required 'name' parameter with no parent field, which may confuse the agent. No disclosure of permissions, idempotency, or return values. Annotations absent so burden is on description.

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

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

Single sentence is concise but lacks necessary detail; it is front-loaded with purpose but omits critical info. Appropriate length for a simple tool but insufficiently informative.

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 low complexity but many siblings, the description should differentiate from create_tag/create_term and explain taxonomy context. It does not, leaving the agent without enough information to choose correctly.

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

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

Schema description coverage is 0% and the description does not explain the sole parameter 'name' (e.g., whether it's a slug or display name). Adds no semantic value beyond the schema.

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

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

Description clearly states the tool creates a category and adds 'with hierarchical support', which distinguishes it from sibling tools like create_tag or create_term. The verb 'Create' and resource 'category' are specific.

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

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

No guidance on when to use this tool versus alternatives such as wordpress_create_tag (tags) or wordpress_create_term (other taxonomies). No prerequisites or common scenarios 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?

No annotations exist, and the description does not disclose important behaviors such as whether it overwrites existing files, requires directory write permissions, or handles errors (e.g., parent theme not found). The description lacks depth for safe invocation.

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

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

The description is very short (one sentence), but it omits critical information. While concise, it does not earn its place by providing sufficient value, resulting in 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 (creating child themes involves copying templates, enqueuing styles, etc.), the description lacks essential details about prerequisites (e.g., parent must be installed), output, and side effects. Without annotations or output schema, it 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?

With 0% schema description coverage, the description fails to explain the parameters 'parentTheme' and 'childName' beyond their names. An agent cannot know expected formats (e.g., theme slug or display name) or constraints, making it difficult to use correctly.

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

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

The description clearly states the verb 'Create' and the resource 'child theme' and specifies it is 'from a parent theme', making it easy to understand the tool's main purpose. It is distinct from sibling tools, though slightly generic.

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

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

No guidance is provided on when to use this tool versus alternatives, such as when creating a theme from scratch or modifying a parent theme. No prerequisites or context are given, leaving the agent to infer usage.

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

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

With no annotations provided, the description bears full responsibility for disclosing behavioral traits. It only states 'Create a comment on a post,' failing to mention consequences like approval requirements, authentication needs, potential errors, or response details. This is insufficient for an agent to understand the tool's side effects.

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

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

The description is extremely concise at one sentence, which is efficient, but it sacrifices necessary detail. While it front-loads the core action, it omits parameter descriptions and usage context, making it insufficiently informative despite its brevity.

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

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

Given the tool has two required parameters, no output schema, and no annotations, the description is grossly inadequate. It does not explain what the tool returns, error conditions, or any behavioral nuances, leaving the agent with dangerously incomplete information 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 input schema has 0% description coverage, meaning the property definitions 'postId' and 'content' lack any textual explanation. The tool description does not compensate by explaining what these parameters represent (e.g., the WordPress post ID format, content restrictions), leaving the agent without semantic context to correctly populate them.

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 directly states the action 'Create a comment on a post,' using a specific verb and resource. It clearly distinguishes itself from sibling tools like 'wordpress_get_comments' (retrieval), 'wordpress_update_comment' (modification), and 'wordpress_delete_comment' (deletion), leaving no ambiguity about its purpose.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as when to create a new comment versus updating or deleting an existing one. It lacks context about prerequisites, typical scenarios, or any conditional advice, leaving the agent without decision-making support.

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 exist, and the description fails to disclose what the tool returns, whether it checks for duplicate names, or any side effects. For a creation tool, stating the output or behavior is essential.

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

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

A single sentence of six words is efficient and front-loaded. However, it could include a bit more detail without becoming verbose, so it's not 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?

Given the absence of output schema and annotations, the description does not specify what happens after creation (e.g., returns menu ID) or error scenarios. For a simple tool, it is partially complete but lacking in outcome details.

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

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

The only parameter 'name' has no description in the schema (0% coverage) and the description adds no further meaning, such as constraints on length, uniqueness, or allowed characters.

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

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

Description states a specific action ('Create') and resource ('navigation menu'), clearly distinguishing from siblings like wordpress_create_menu_item or wordpress_assign_menu_to_location. However, it lacks any qualifiers or scope details (e.g., empty menu creation) that would make it 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 on when to use this tool versus alternatives (e.g., after creating a menu, one might need to add items or assign to location). No prerequisites or context for effective use are provided.

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

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

With no annotations, the description must disclose behavioral traits. It only says 'Add' without indicating side effects, authentication needs, or whether it modifies existing items.

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 short (4 words), but at the expense of necessary detail. It does not earn its place as it fails to convey critical 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 no annotations, no output schema, and 0% schema coverage, the description is grossly insufficient. It lacks return value info, error conditions, and any usage hints.

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

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

Schema description coverage is 0% and the description does not explain the parameters (title, menus). No examples, defaults, or constraints provided.

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

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

The description 'Add an item to a navigation menu' clearly states the action and resource. It distinguishes from siblings like wordpress_create_menu (which creates the menu itself) implicitly, but does not explicitly mention alternatives.

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

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

No guidance on when to use this tool versus alternatives like wordpress_update_menu_item or wordpress_create_menu. No context on prerequisites, such as needing an existing menu ID.

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

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

Annotations are absent, so the description must disclose behavioral traits. It mentions 'hierarchy support' but does not explain what that entails (e.g., a 'parent' parameter is missing from the schema). It also does not state whether the operation is safe, destructive, or requires authentication.

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 (8 words), which is good, but it omits necessary details. It front-loads the main action, yet fails to provide a structured explanation of behavior or parameters, making it insufficiently informative despite its brevity.

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

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

Given the tool's simplicity (2 params, no output schema, no annotations), the description is too sparse. It lacks information about return values, error conditions, hierarchy implementation, or any side effects. A more complete description would cover these aspects.

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

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

With 0% schema description coverage, the description is expected to explain the parameters. It only references 'hierarchy support' but says nothing about 'title' or 'content' – their format, constraints, or role in page creation. The schema provides no descriptions, so the agent gains no semantic help.

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 ('Create') and the resource ('WordPress page'), and adds 'with hierarchy support' to hint at parent-child page relationships. It implicitly distinguishes from 'create_post' for posts, but does not explicitly differentiate from other creation tools like 'create_category' or 'create_comment'.

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 'wordpress_create_post' or 'wordpress_bulk_create_posts'. The description does not specify prerequisites, context, 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 provided; description fails to disclose default post status (draft vs published), required capabilities, or side effects. Vague 'create' without 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?

Single sentence is efficient, but the phrase 'full control over all post properties' is inaccurate given schema constraints, slightly undermining 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 no output schema and no behavioral details, description is insufficient for a create tool. Agent lacks knowledge of expected output, required permissions, or default 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?

Schema has 0% description coverage for parameters; description adds no semantic detail beyond parameter names. Claim of 'full control' misrepresents limited schema (only title and content).

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?

Describes creating a WordPress post, distinguishing from siblings like wordpress_create_page. However, claim of 'full control over all post properties' is misleading given only title and content are in schema.

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

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

No guidance on when to use this tool versus alternatives like wordpress_bulk_create_posts, wordpress_publish_post, or wordpress_update_post. Agent has no context for selection.

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

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

No annotations provided, and the description fails to disclose behavioral traits such as whether existing redirects are overwritten, permission requirements, or response behavior. Carries full burden but delivers minimal info.

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?

Extremely concise: one sentence with no wasted words. Front-loads the action and parameters effectively.

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

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

Despite 0% schema coverage and no output schema, the description is too brief. Lacks error handling, success conditions, or any context beyond the basic action. For a creation tool, more detail is expected.

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

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

Schema has 0% description coverage; parameter names source and destination are intuitive but no format details. Description introduces redirect types (301, 302, 307) not represented in schema, causing confusion.

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 'Create URL redirect' and specifies the redirect types (301, 302, 307), distinguishing it from other tools like wordpress_delete_redirect.

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

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

No guidance on when to use this tool versus alternatives, prerequisites, or conditions. Does not mention required plugins or compatibility.

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

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

The description simply states the action but lacks behavioral details such as side effects, permissions required, or expected outcomes. With no annotations, this provides minimal 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 overly concise, consisting of a single sentence that adds no value beyond the tool's name. It is under-specified rather than efficiently written.

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, output schema, and parameter descriptions, the description is completely inadequate. It does not explain the WordPress concept of reusable blocks or provide necessary context for correct 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?

The input schema has 0% description coverage, and the description fails to explain the meaning of 'title' or 'content'. No additional semantics are provided.

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

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

The description 'Create a reusable block' is a tautology, restating the tool's name without adding specificity. It does not distinguish itself from siblings like wordpress_update_reusable_block or wordpress_delete_reusable_block.

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. Without context, an agent cannot determine if this tool is appropriate for a given task.

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, the description carries full burden. It labels the tool as 'create', implying a mutation, but fails to disclose side effects (e.g., role conflict, default permissions, required user capabilities). This lack of detail hinders safe invocation.

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

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

At five words, the description is extremely concise, but this brevity sacrifices necessary context. While it contains no wasted words, it omits structural elements (e.g., sections, examples) that would improve usability.

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 state-modifying tool with no output schema and no annotations, the description is incomplete. It fails to mention return values, error conditions, or required permissions, leaving significant gaps for an AI agent to operate safely.

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

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

Schema description coverage is 0%, and the description adds no meaning beyond parameter names. It does not explain that 'role' is likely a slug (must be unique) or that 'displayName' is the human-readable label, leaving critical semantics unspecified.

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 ('Create') and resource ('custom user role'), which distinguishes it from siblings like 'wordpress_assign_role' or 'wordpress_delete_role'. However, it lacks any explanation of what 'custom' entails or how it differs from built-in roles, leaving some ambiguity.

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

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

No guidance is provided on when to use this tool versus alternatives such as 'wordpress_add_capability' (for modifying existing roles) or 'wordpress_assign_role' (for user assignment). An AI agent would need to infer usage 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 full burden. It only says 'Create a new tag' without disclosing behavioral traits like idempotency, duplicate handling, permissions required, or side effects.

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

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

The description is extremely concise (only 4 words) with no wasted text. However, it lacks structure and could be expanded slightly for clarity without losing 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 low complexity (1 parameter, no output schema), the description is incomplete. It does not explain return values, prerequisites, or any constraints. A more complete description would mention what happens on success or failure.

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

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

Schema description coverage is 0%, and the description adds no extra meaning for the 'name' parameter. It does not specify format, length limits, uniqueness, or any constraints beyond the schema's type string.

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

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

The description clearly states it creates a new tag, which is a specific WordPress entity. It distinguishes from siblings like wordpress_create_category and wordpress_create_term by specifying 'tag' instead of a general term.

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 vs alternatives like wordpress_create_term or wordpress_create_category. There is no mention of prerequisites or context for use.

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

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

With no annotations, the description must disclose all behavioral traits. It only says 'Create a new term' without detailing side effects, required permissions, or the structure of the term created. The description does not contradict missing annotations, but it 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 short sentence, which is concise, but it borders on under-specification. It could be expanded with essential details without being verbose.

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

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

Given no output schema and no annotations, the description should compensate by explaining the return value, required inputs, and usage context. It fails to do so, leaving the agent with insufficient 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 input schema has 0% description coverage; the parameters 'taxonomy' and 'name' are not explained beyond their names. The description adds no meaning, leaving the agent to guess formats or constraints.

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

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

The description clearly states 'Create a new term in a taxonomy', which indicates the action and resource. However, it does not differentiate from sibling tools like create_category or create_tag, which are more specific types of term creation.

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 create_category or create_tag. There are no exclusions, prerequisites, or context hints given.

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

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

With no annotations, the description carries full burden but only states basic creation. It omits behavioral traits such as password validation, duplicate handling, or default role assignment.

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

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

Single sentence, no wasted words. However, it is too brief given the tool's complexity and missing parameter 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 3-parameter creation tool with no output schema or annotations, the description is insufficient. It does not cover success signals, error conditions, or role assignment mechanics.

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

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

Schema has 0% description coverage for three parameters. Description mentions 'with roles' but the schema has no roles parameter, creating inconsistency and adding confusion rather than clarity.

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

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

The description clearly states the verb 'Create' and resource 'WordPress user', and hints at role assignment with 'with roles', distinguishing it from siblings like wordpress_update_user and wordpress_assign_role.

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

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

No guidance on when to use this tool vs alternatives, no prerequisites or limitations mentioned, and no comparison with related tools like wordpress_assign_role.

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 only states the action (deactivation) without indicating side effects (e.g., loss of settings, impact on site functionality), error conditions (e.g., plugin not found), or permission requirements. The description is insufficient for understanding the tool's full impact.

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 short (one phrase), which is concise but at the expense of essential details. It is not efficiently structured to provide necessary context; it sacrifices substance for brevity.

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

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

Given the low schema coverage (0%), missing annotations, and no output schema, the description is critically incomplete. It fails to specify valid plugin identifiers, error handling, or the expected result. The tool's simplicity does not excuse the lack of detail, as the agent still needs guidance 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 description adds no semantic meaning to the single 'plugin' parameter. The input schema has 0% description coverage, and the description does not clarify what format the plugin identifier should take (e.g., slug, file name). This leaves the agent without necessary guidance on how to correctly fill the parameter.

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 'Deactivate a plugin' uses a clear verb and resource, making the tool's purpose immediately understandable. It effectively distinguishes itself from sibling tools like 'wordpress_activate_plugin', though it could be slightly more specific by indicating that the plugin is identified by its slug.

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

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

No usage guidelines are provided. The description does not specify when to use this tool (e.g., to disable a plugin temporarily) or when not to (e.g., if the plugin is already deactivated). It also fails to mention any prerequisites, such as the plugin needing to be installed and currently active.

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 does not state that the deletion is permanent, whether authentication is required, or if there are side effects on other operations (e.g., scheduled backups). The agent has no safety 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 description is concise at one short sentence, but at the expense of valuable information. Every word earned its place, but the description is under-specified for the required task.

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

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

For a simple single-parameter tool, the description should at least explain the parameter and expected outcome. It misses return value, error cases, and how to obtain the backupId. Sibling tools like wordpress_list_backups provide context but are not referenced.

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

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

Schema coverage is 0%, and the description does not explain the parameter 'backupId'. The agent cannot infer what value to provide, its source (e.g., from wordpress_list_backups), or its format. The description adds no meaning beyond the schema.

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

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

Description 'Delete a backup file' clearly states the action (delete) and the resource (backup file). It distinguishes from general file deletion tools like wordpress_delete_file by specifying 'backup file'. However, it could be more specific about the scope of backups (e.g., WordPress backup system).

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

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

No guidance on when to use this tool versus alternatives like wordpress_delete_file or wordpress_restore_backup. The agent is left to infer context from the tool name alone. There is no mention of prerequisites (e.g., backup must exist) or when deletion is 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, the description must disclose behavioral traits. It only states it deletes a category, but does not mention effects on associated posts, reversibility, or the role of the 'force' parameter. The agent lacks information about the operation's implications.

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

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

The description is a single concise sentence. It is appropriately short and front-loaded, with no unnecessary words. However, it could be slightly expanded to include parameter details without losing conciseness.

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

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

Given the tool has 2 required parameters and no output schema, the description is incomplete. It fails to explain the purpose of the 'force' parameter, any side effects, or the relationship to sibling tools. More context is needed for correct invocation.

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

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

Schema description coverage is 0%, so the description should compensate. However, it does not describe the 'categoryId' or 'force' parameters, leaving the agent to infer meaning from parameter names alone. The description adds no semantic value beyond the schema.

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

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

The description 'Delete a category' clearly states the verb (delete) and resource (category). It distinguishes from sibling tools like wordpress_delete_tag and wordpress_delete_term, as 'category' is a specific taxonomy. However, it does not add any extra context such as 'by ID' to clarify the required 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?

No guidance is provided on when to use this tool versus alternatives like wordpress_update_category or wordpress_delete_term. The description does not mention prerequisites, when not to use, or scenarios where other tools would 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 exist; description only says 'Delete a comment'. Fails to disclose behavioral traits such as whether comments are trashed or permanently deleted, or if permission checks are involved.

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?

Extremely short (three words), but lacks necessary detail. Front-loaded but not sufficiently informative.

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 two required parameters and no output schema, the description is incomplete. It omits return values, side effects, and error handling, making it insufficient for reliable tool 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 description coverage is 0% and description adds no meaning. The 'force' parameter is not explained, leaving ambiguity about its effect. No value added beyond names.

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

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

Description clearly states 'Delete a comment' with verb and resource. It distinguishes from siblings like create or update, but doesn't clarify whether deletion is permanent or moves to trash.

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

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

No guidance on when to use this tool versus alternatives like bulk deletion or trashing. No prerequisites or context 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?

No annotations exist, so the description carries the full burden. It only mentions optional backup but does not disclose whether the deletion is permanent, requires permissions, affects directories, or what happens on failure. Minimal behavioral context.

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

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

The description is extremely short (4 words) and lacks essential structure. While concise, it sacrifices critical information needed for correct tool usage.

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

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

Given no output schema, two required parameters with zero description coverage, and no annotation, the description is woefully incomplete. The agent cannot determine return values, error handling, or the tool's full 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?

Schema description coverage is 0%, so the description must explain parameters. It does not describe the 'path' parameter at all and only hints at 'createBackup' without explaining its effect or defaults. The agent receives no meaningful parameter guidance.

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 (delete) and resource (file) and mentions the optional backup feature, distinguishing it from other file operations. However, it could provide more context about the scope of files (e.g., WordPress filesystem).

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

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

No guidance on when to use this tool vs alternatives, no prerequisites, no context on when to set createBackup=true. The agent must infer usage 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?

The description implies a destructive operation but lacks details such as whether force=true is required for permanent deletion, permission requirements, or side effects. Without annotations, the agent is left unaware of important behavioral traits.

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

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

The description is a single short sentence, which is concise but at the cost of omitting essential information. It fails to provide a complete picture, thus not earning 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?

Given no output schema, no annotations, and two unparameterized params, the description is severely incomplete. It does not specify return values, error cases, or behavioral nuances, leaving the agent poorly informed.

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

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

Schema description coverage is 0% and the description does not explain the meaning or role of mediaId or force. The force parameter's boolean nature is critical but completely undefined, making it difficult for an agent to invoke correctly.

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 'Delete a media file from library' clearly states the action (delete) and the resource (media file from library). It distinguishes from siblings like upload_media, update_media, and bulk_delete_media.

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 wordpress_bulk_delete_media, or how the force parameter affects behavior (e.g., trash vs permanent delete). No context on prerequisites or best practices.

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 present, the description carries full burden. It only states the action without explaining side effects (e.g., whether deleting a menu also deletes its items or requires permissions). No behavioral details beyond the obvious.

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 brief but under-specified. True conciseness would include essential details within a compact format; here it sacrifices clarity for brevity.

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

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

Given the simple input schema and no output schema, the description is inadequate. It fails to specify what happens upon success/failure, the role of 'force', or any side effects on associated menu items.

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

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

Schema description coverage is 0%, yet the description does not explain the two parameters ('menuId' and 'force'). The meaning of 'force' is critical for safe use but remains ambiguous.

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 'Delete a navigation menu' clearly states the action and resource. It distinguishes from sibling tools like 'create_menu', 'get_menus', and 'update_menu_item' by specifying the delete operation.

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

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

No guidance is provided on when to use this tool versus alternatives (e.g., 'delete_menu_item'). There is no mention of prerequisites, contexts, or which tool to use for partial deletions.

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?

While 'delete' implies a destructive action, the description provides no additional behavioral context such as irreversibility, permission requirements, or side effects. With no annotations, the description should disclose more about 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 extremely concise (4 words) but at the expense of informativeness. It fails to provide any value beyond restating the tool name, making it too brief for effective tool selection.

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 no output schema, no annotations, and minimal description, the tool lacks essential context. Return values, side effects, error conditions, and parameter semantics are all missing, leaving the agent uninformed.

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 does not mention the two parameters (itemId and force) at all. Schema coverage is 0%, so the description should explain these parameters, especially the 'force' boolean which is non-obvious.

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 'Delete a menu item' clearly specifies the action (delete) and the resource (menu item). It distinguishes from sibling tools like create, update, or get menu items, but it is minimal and could be more precise.

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

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

No guidance on when to use this tool vs. alternatives (e.g., update_menu_item or bulk deletion). No mention of prerequisites or contexts where deletion is appropriate or not.

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, the description carries full burden for behavioral disclosure. It only states the action without detailing side effects (e.g., permanent removal vs trash, impact on media or metadata). No behavioral traits are disclosed.

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

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

While the description is short (3 words), it sacrifices essential information for brevity. It is under-specified, which hampers understanding rather than promoting efficient communication.

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 deletion (2 required parameters, no output schema, no annotations), the description is severely incomplete. It fails to explain the operation's impact, return value, or preconditions, leaving the agent with insufficient context.

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

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

Schema description coverage is 0%, and the tool description adds no meaning to the parameters 'pageId' and 'force'. It does not clarify what pageId refers to (e.g., ID from get_pages) or what force implies (e.g., bypassing trash).

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 'Delete a page' clearly states the action and resource. It is specific enough to indicate removal of a WordPress page, though it does not differentiate from similar sibling tools like delete_post or delete_media, but the tool name 'wordpress_delete_page' already 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?

No guidance is provided on when to use this tool versus alternatives (e.g., delete_post for posts, trash vs permanent delete). The force parameter is not explained, leaving the agent uncertain about typical invocation scenarios.

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?

Without annotations, the description carries full burden. It mentions the precondition but fails to disclose side effects (permanent removal, data loss) or any return value. This is insufficient for an agent to assess risks.

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, using a single sentence with a parenthetical note to convey the core purpose and prerequisite. No unnecessary words.

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

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

Given the simplicity of the tool (1 param, no output schema, no annotations), the description barely meets minimum viability. It lacks details on parameter format, permanence of deletion, and what happens to plugin data.

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

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

The input schema has 0% description coverage for the 'plugin' parameter. The description adds no information about what value it expects (slug, name, or path), relying solely on the schema which only says string.

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 (delete) and resource (plugin), and includes a necessary precondition (must be deactivated). However, it does not specify permanence or distinguish precisely from related tools like deactivate.

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 a crucial usage requirement (must be deactivated first) but does not offer guidance on when to use this tool versus alternatives like wordpress_deactivate_plugin or how to identify the correct plugin identifier.

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 provided, so description carries full burden. It explains the key behavioral difference between permanent deletion and moving to trash. However, it does not disclose side effects like deletion of related data (comments, meta) or restoration possibilities from trash.

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

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

Two sentences, no wasted words. Front-loaded with the action 'Delete a post'. Efficient and direct.

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 no output schema and low complexity, the description covers the essential functionality. Lacks mention of return value or error cases (e.g., post not found), but for a deletion tool this is acceptable.

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

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

Schema coverage is 0% so description must compensate. It adds meaning to the force parameter ('permanently delete' vs 'moves to trash') but does not describe postId beyond its name and type in schema. The parameter description is helpful for force but postId is left implicit.

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 'Delete a post' and explains the two modes via the force parameter: 'Set force=true to permanently delete, otherwise moves to trash'. This differentiates it from sibling tools like wordpress_bulk_delete_posts and wordpress_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 guidance on when to use this tool versus alternatives like wordpress_bulk_delete_posts or wordpress_update_post (to trash). Does not mention prerequisites, consequences, or when deletion is 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 bears full responsibility for behavioral disclosure. It fails to mention that the operation is destructive, whether confirmation is needed, what happens if redirectId is invalid, or any authentication or permission requirements. The description 'Delete URL redirect' imparts no behavioral insight.

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 very short (three words) but not appropriately sized. It is under-specified, lacking any contextual or structural elements. While not verbose, the brevity leads to insufficient information, making it closer to a tautology than a helpful 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 has one required parameter, no output schema, and no annotations, the description is critically incomplete. It does not mention return values (e.g., success/error response), side effects (e.g., permanent deletion), or any contextual triggers. The description fails to provide a complete picture for an agent to use the tool correctly.

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

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

The input schema has one required parameter 'redirectId' of type number, but the schema_description_coverage is 0%, meaning no descriptions exist in the schema itself. The description does not explain what redirectId represents, how to obtain it, or any constraints (e.g., existence). It adds no semantic value beyond the schema.

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

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

The description 'Delete URL redirect' clearly states the action and resource, matching the tool name. However, it does not distinguish this delete operation from other wordpress_delete_* siblings (e.g., delete_post, delete_page), as they all share similar phrasing. The purpose is clear but lacks 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 regarding when to use this tool versus alternatives, such as wordpress_get_redirects for listing redirects before deletion. There is no mention of prerequisites, typical use cases, or situations where deletion is inappropriate.

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 present, so the description carries the full burden. It only states 'Delete a reusable block' without disclosing important behaviors such as whether the deletion is permanent, what happens if the block is in use, or required permissions. This is insufficient for a destructive operation.

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 (5 words), but it is under-specified. While front-loaded, it lacks essential details such as parameter descriptions or usage context, making it more of a placeholder than a helpful 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 lack of output schema and annotations, and the simplicity of the parameters, the description is grossly incomplete. It does not explain the purpose of the 'force' parameter, the result of the operation, or any potential side effects, making it inadequate for reliable tool invocation.

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

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

Schema description coverage is 0%, meaning the description adds no meaning to the parameters (blockId and force). It does not explain what 'force' does or how 'blockId' is used. The agent must rely solely on parameter names and types, which are insufficient for correct invocation.

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

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

The description clearly states the verb 'Delete' and the resource 'reusable block', which is specific and matches the tool name. However, it does not differentiate from sibling delete tools like wordpress_delete_post or wordpress_delete_page, but the purpose is unambiguous.

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

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

No guidance on when to use this tool versus alternatives like wordpress_delete_post or wordpress_delete_page. No prerequisites or context are provided, leaving the agent to infer the appropriate use case.

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

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

With no annotations, the description bears full responsibility for disclosing behavioral traits. It only states the destructive action but does not mention side effects (e.g., users assigned to the role may lose permissions), reversibility, or required permissions.

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

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

The description is a single sentence, which is concise but overly terse. It front-loads the action and resource, but lacks crucial context that an agent needs, making it too sparse for reliable use.

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

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

Given the simplicity (one parameter) but no annotations or output schema, the description should provide more complete context. It fails to address what happens after deletion, how to identify the role, and any constraints, leaving the agent underinformed.

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 0% description coverage, and the tool description does not explain the 'role' parameter beyond its name. It does not clarify whether the value should be a slug, name, or ID, nor does it specify that the role must exist and be custom.

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 ('Delete') and the resource ('custom user role'), which distinguishes it from sibling tools like create_role, assign_role, and remove_capability. However, it does not specify whether built-in roles are also deletable, which could lead to confusion.

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

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

No guidance is provided on when to use this tool versus alternatives like remove_capability or delete_user. There is no mention of prerequisites, such as ensuring the role is custom or that users with the role should be handled first.

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, the description bears full burden for behavioral disclosure. The brief statement 'Delete a term' does not explain the meaning of the `force` parameter, whether deletion is permanent, or what happens when a term is in use. This leaves significant gaps for an AI agent.

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 short—one sentence. While concise, it omits critical details, making it under-specified rather than efficiently informative. It does not front-load essential usage 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 lack of annotations, output schema, and parameter descriptions, the description is incomplete. It does not cover important aspects like what the `force` parameter does, error conditions, or return values. For a simple 3-parameter tool, it still fails to provide sufficient context.

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

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

Schema description coverage is 0%, meaning no parameter descriptions exist in the schema. The tool description adds no information about the parameters (taxonomy, termId, force). An agent has to rely solely on parameter names, which is insufficient for correct invocation.

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

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

The description clearly states 'Delete a term from a taxonomy', which is a specific verb and resource. It distinguishes from sibling tools like create_term, update_term, or get_terms. However, it lacks any additional context that could enhance clarity.

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

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

No usage guidelines are provided. The description does not indicate when to use this tool versus alternatives (e.g., wordpress_delete_category, wordpress_delete_tag), nor does it mention any prerequisites or consequences.

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 only mentions the active theme constraint but does not disclose what force does, whether deletion is permanent, or effects on child themes. This is insufficient for a mutation tool.

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 very short and front-loaded, but critical information is missing. It is concise but incomplete, earning a middle score.

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 no annotations, no output schema, and minimal description, the tool is not complete enough for the agent to use correctly. The force parameter and return behavior remain opaque.

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

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

Schema description coverage is 0%, so the description must explain parameters. It does not explain 'stylesheet' (likely the theme identifier) or 'force' (its role). The agent has no guidance on how to fill these parameters.

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

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

The description clearly states the action (delete) and the resource (theme), with a specific constraint (cannot delete active theme). This distinguishes it from sibling tools like wordpress_activate_theme or wordpress_delete_plugin.

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 many sibling deletion tools, the agent needs context on when to choose this one, but none is given.

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

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

With no annotations, the description discloses the destructive action and reassignment behavior, but omits details like irreversibility, permission requirements, or fallback behavior if reassign parameter is invalid.

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

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

Single sentence with parenthetical clarification, no redundant words. Perfectly concise.

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

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

For a deletion tool with two required params and no output schema, the description covers the core action but lacks details on return value, error cases, and prerequisite conditions, leaving 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 has 0% description coverage, and the description only indirectly explains 'reassign' as reassigning content. It does not clarify that 'userId' is the WordPress user ID or that 'reassign' must be a valid user ID, adding minimal value beyond parameter names.

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

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

Description clearly states 'Delete a user (reassign their content to another user)', specifying the verb (delete) and resource (user), and distinguishes from other delete tools by mentioning content reassignment.

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

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

The description implies usage for deleting a user with content handling, but lacks explicit when-to-use or when-not-to-use guidance, and does not reference alternatives among siblings.

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

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

No annotations provided, and description only states the action without disclosing side effects (e.g., permanent deletion, what happens to widget settings) or the meaning of the 'force' parameter. For a deletion tool, behavioral context is minimal.

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

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

Description is a single short sentence, which is concise but lacks structure. While it is front-loaded, it omits important details; conciseness should not sacrifice completeness.

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 annotations, no output schema, and a minimal description, the tool is poorly documented. The agent lacks essential context to decide when to use it and what to expect, especially given the large number of sibling tools.

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

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

Input schema has 0% description coverage, and the description does not explain either parameter (widgetId or force). The agent gets no additional meaning beyond the parameter names and types.

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

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

Description clearly states verb 'delete' and resource 'widget from a sidebar', distinguishing it from update or get tools. However, it's ambiguous whether the widget is removed from all sidebars or a specific one, but the action is clear.

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

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

No guidance on when to use this tool vs alternatives (e.g., update_widget, get_widgets). No prerequisites or conditions for use, such as widget existence or force flag implications.

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, the description must disclose behaviors. It fails to mention that the operation creates a new post, duplicates metadata, or returns anything. The word 'Duplicate' implies a write operation, but risks are not stated.

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 very short and front-loaded, but it omits critical information. While concise, it sacrifices completeness.

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 duplication (side effects, what gets copied, output), the description is severely lacking. No output schema or further details make it incomplete.

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

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

The description says 'optional new title' but the schema requires newTitle. This contradiction misleads the agent. Schema coverage is 0%, and the description adds no useful parameter details beyond the contradiction.

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 ('Duplicate an existing post') and the resource, with an optional parameter for new title. It distinguishes from sibling tools like create_post, update_post, and delete_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 guidance on when to use this tool versus alternatives (e.g., create_post for new posts, update_post for edits). Missing context on prerequisites or when not to use it.

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

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

No annotations are provided, placing full burden on the description. The description only states the action without disclosing side effects, state changes, or postconditions (e.g., whether users are blocked). Insufficient for an agent to anticipate consequences.

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 very concise at one sentence. While brevity is positive, the structure lacks any breakdown (e.g., separating enable/disable cases). Still, it avoids verbosity.

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

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

Given the tool's simplicity (no parameters, no output schema), the description still omits critical context: return values, state change behavior, or error conditions. An agent would need to guess or infer operation details.

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

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

The input schema has zero parameters, so the description need not explain parameters, but it fails to clarify how the tool determines whether to enable or disable (e.g., toggling based on current state). This ambiguity undermines correct invocation.

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

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

The description clearly states the verb-resource pair: enables or disables WordPress maintenance mode. It distinguishes the tool from siblings, as no other tool appears to manage maintenance mode.

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

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

The description provides no guidance on when to use this tool vs alternatives, no prerequisites, and no indication of how to choose between enabling or disabling. This lack of direction leaves the agent without decision-making support.

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 present, so the description must disclose behavioral traits. It does not warn that executing shortcodes can run arbitrary code, have side effects, or require specific permissions. This is a significant gap for a potentially destructive operation.

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 short sentence, which is concise but at the expense of necessary details. It does not earn its place by being sufficiently informative.

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 should compensate by explaining input format, expected output, and potential risks. It fails to do so, leaving the tool under-specified for safe and 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 'content' has no schema description (0% coverage). The description does not explain the expected format (e.g., '[shortcode]'), examples, or constraints, leaving the agent to guess.

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

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

The description 'Process and execute a shortcode string' indicates the tool runs a shortcode, but it is vague on what 'process' entails and what output is produced. It distinguishes minimally from siblings like 'wordpress_list_shortcodes' but lacks specific verb+resource clarity.

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

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

No guidance provided on when to use this tool versus alternatives such as inserting the shortcode into a post or checking existence. The description does not mention prerequisites or 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?

No annotations are provided, so the description carries full burden. It discloses the allowed query types for safety, but does not mention result format, authentication needs, rate limits, or any side effects. The read-only nature is implied but not stated.

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

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

The description is a single concise sentence that front-loads the purpose and constraint. However, it is so brief that it omits important details, making it efficient but under-specified.

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, no annotations, and a single parameter, the description is insufficient. It does not explain return format, error handling, or how results are delivered. For a SQL execution tool, this is a significant gap.

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

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

The single 'query' parameter has no schema description (0% coverage). The description only says 'Execute SQL query' without adding format, length, or example. It does not compensate for the missing schema info.

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

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

The description clearly states the tool executes SQL queries and specifies acceptable query types (SELECT, SHOW, DESCRIBE, EXPLAIN). This distinguishes it from other WordPress database tools like wordpress_list_tables or wordpress_get_table_structure.

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

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

The description implies usage for safe read-only queries by listing allowed types, but does not explicitly provide when to use versus alternatives or when not to use it. No guidance on exclusions is given.

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

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

With no annotations, the description must fully disclose behavioral traits. It only says 'Export posts/pages as WordPress XML', omitting whether it exports all or selected items, if it modifies data, or how output is handled (e.g., file download vs. return).

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?

Concise, front-loaded sentence. Could benefit from a bit more context, but it avoids unnecessary verbosity.

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 no output schema and no annotations, the description is too minimal. It doesn't explain the XML content scope or how the export is delivered, leaving the agent without crucial details.

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

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

The input schema has no parameters, so description doesn't need to add param info. It clarifies the scope (posts/pages) and format, which is useful. Baseline for 0 params is 4.

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

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

The description clearly states the action (Export), resource (posts/pages), and output format (WordPress XML). It distinguishes itself from siblings like import_content and get_posts.

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

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

No guidance on when to use this tool vs alternatives. Among many siblings, the description does not explain why an agent would pick export over other content retrieval or creation 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?

No annotations are provided, so the description carries the full burden. It only states it gets file info, implying a read operation, but does not disclose limitations, authorization needs, or potential side effects. For a simple read tool, minimal info is provided.

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

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

The description is a single sentence with no redundant words. It is appropriately short for the tool's simplicity.

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

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

The tool has one parameter and no output schema, yet the description does not explain the return value format or structure. The agent lacks information about what to expect from the tool's output, making it incomplete for 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?

With 0% schema description coverage, the description adds little meaning to the 'path' parameter. It does not clarify expected format (absolute/relative, server path, URL) or any constraints, leaving the agent to guess.

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

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

The description clearly states the tool gets file information and lists specific attributes (size, modified date, permissions). This distinguishes it from siblings like wordpress_list_files (which lists files) and wordpress_read_file (which reads content).

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

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

No guidance on when to use this tool versus alternatives like wordpress_list_files or wordpress_scan_permissions. The agent must infer from the name and attributes, which is insufficient among many sibling tools.

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

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

No annotations are provided, and the description does not disclose potential impacts such as performance implications or required permissions. For a mutation operation like flushing rules, the agent should be warned about possible side effects.

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

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

The description is a single, concise sentence that conveys the core purpose. It is appropriately sized and front-loaded, though it could include slightly more detail.

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

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

For a parameterless tool focused on a specific fix, the description is mostly complete. However, it lacks behavioral context that would help the agent understand prerequisites or risks, such as whether it requires administrative access or if it is safe to run frequently.

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

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

The tool has no parameters, so the schema coverage is effectively 100%. The description adds no parameter information, but according to the rubric, 0 parameters warrants a baseline score of 4.

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

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

The description clearly states the action ('Flush') and the resource ('WordPress rewrite rules') along with the benefit ('fixes permalink issues'). It is specific and distinct from sibling tools like 'wordpress_clear_cache'.

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

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

The description implies usage when fixing permalink issues, which is helpful. However, it does not explicitly mention when not to use it or provide alternatives, but given the simplicity, this is acceptable.

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, the description must disclose behavioral traits. It only states the action ('create backup') without detailing side effects (e.g., overwriting existing backups), required permissions, or whether the backup is synchronous. The agent is left unaware of important operational aspects.

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

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

A single sentence that is front-loaded and contains no redundant information. Every word serves a purpose, making it highly efficient for the agent to parse.

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

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

Given the complexity (backup operation) and absence of output schema, the description lacks details on return values or storage location. No annotations compensate. The simple description may be adequate for a zero-parameter tool but leaves ambiguity about what the agent receives after 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 input schema has zero parameters, so the description does not need to explain parameters. The baseline for zero parameters is 4, and the description adds value by clarifying the backup scope (files + database), which is not evident from the empty schema.

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

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

The description clearly states 'Create complete site backup (files + database)', specifying the verb and resource. It differentiates from sibling tools like wordpress_backup_database and wordpress_backup_files, which are partial backups, making the tool's distinct purpose evident.

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

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

No explicit guidance on when to use this tool versus the partial backup siblings. The distinction is implied by the names and description, but the description does not directly advise the agent on selection criteria or prerequisites.

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

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

With no annotations, the description carries the full burden, but it fails to disclose any behavioral traits such as potential side effects, permissions required, or whether the sitemap is regenerated or appended. The description is too vague.

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

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

The description is a single sentence that concisely conveys the action. It is front-loaded with the verb 'Generate' and the resource, with no unnecessary words.

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

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

Despite the tool's simplicity, the description lacks context about the effect, idempotency, or return value. An agent would not know if the sitemap is created anew or updated, or what to expect after execution.

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

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

The tool has zero parameters, so the input schema is completely covered. The description appropriately reflects no parameters, earning a baseline of 4 since there is nothing more to explain.

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

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

The description clearly states the action 'Generate XML sitemap for search engines' with a specific verb and resource. It distinguishes itself from sibling tools, none of which generate sitemaps, so the purpose is unambiguous.

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

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

No guidance on when or when not to use this tool is provided. There is no mention of alternatives, prerequisites, or typical scenarios, which leaves the agent without 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?

No annotations provided, so description carries full burden. It lacks details about permissions, read-only nature, response format, or side effects. Just states what it does without 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.