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

With no annotations, the description carries full responsibility for behavioral disclosure. 'Activate a plugin' implies a state change but does not mention side effects, required permissions, error conditions, or return behavior. This is minimal disclosure for a mutation 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 only three words, which is too underspecified to count as efficient conciseness. It omits essential usage and parameter details, making it closer to an unhelpful stub than a concise description.

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

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

The tool is simple, but with no output schema and no annotations, the description must be more complete. It offers no information about prerequisites, side effects, or the tool's role among many plugin-related siblings, leaving the agent without enough context for correct invocation.

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

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

The schema has one required string parameter 'plugin' with no description, and schema description coverage is 0%. The tool description adds nothing about what format the plugin identifier should take (slug, path, name), leaving the parameter ambiguous and failing to compensate for the schema gap.

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

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

The description uses the verb 'Activate' with the resource 'plugin', clearly stating the action and resource. It is not a tautology and is distinguishable from sibling tools like wordpress_deactivate_plugin or wordpress_delete_plugin, though it lacks any detail about the plugin's identity or activation scope.

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

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

No usage context is provided. The description does not state when to use this tool versus alternatives like wordpress_get_plugin_status, wordpress_plugin_exists, or wordpress_deactivate_plugin, nor does it mention prerequisites such as the plugin being installed or the user having permissions.

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. It does disclose that the selected theme becomes the active theme, implying the previous theme is no longer active. However, it does not mention side effects (e.g., whether the old theme remains installed), potential failure conditions, or permission requirements. The core behavior is clear, but additional context is absent.

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 purpose. Every word contributes meaning, with no unnecessary filler or repetition. It is appropriately sized for the simplicity of the operation.

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

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

For a simple one-parameter tool, the description covers the action's essence, but it does not address the meaning of 'stylesheet' or the expected outcome in terms of site state. Given the lack of output schema and annotations, a bit more context (e.g., how to identify the theme) would make it complete. It is a minimum viable description.

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

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

The schema has zero description coverage for the required 'stylesheet' parameter, and the tool description does not explain what 'stylesheet' means or how to obtain it. The parameter name is technical and may be unclear to users unfamiliar with WordPress theme internals. The description adds no value beyond the raw 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 action ('Activate a theme') and explicitly clarifies the consequence ('switch to it as the active theme'). It distinguishes this tool from sibling tools like get_themes, delete_theme, or create_child_theme by making the activation intent unambiguous.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., theme must be installed), nor does it suggest checking current active theme first with get_active_theme. The description is purely a statement of function and offers no contextual usage advice.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states the basic action and gives no information about side effects, idempotency, permissions required, or what happens if the capability already exists.

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

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

A single, front-loaded sentence conveys the core function without unnecessary words. It earns its place and could not be shorter without losing meaning.

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

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

For a tool with two string parameters and no annotations or output schema, the description is too sparse. It lacks explanations of WordPress capability semantics, role requirements, or expected input formats, leaving the agent to guess.

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 there are no enums. The description mentions 'role' and 'capability' only through the action phrase, adding no detail about valid values, formats, or examples. It does little beyond restating the parameter names.

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

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

The description clearly states a specific action ('Add') and a specific resource ('capability to a user role'). This distinguishes it from sibling tools like remove_capability and assign_role, which have different actions or targets.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention prerequisites, such as the role needing to exist, nor does it contrast with remove_capability or other role-related tools.

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

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

No annotations are provided, so the description carries the full burden of disclosing side effects and behavior. 'Analyze' implies a read-only operation, but the description does not explicitly state non-mutation, return format, or any dependencies (e.g., an SEO plugin), leaving key behavioral aspects undisclosed.

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

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

The description is a single, front-loaded sentence with no filler or redundancy. It conveys the core purpose efficiently, though it could be more informative 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 minimal schema, lack of annotations, and absence of an output schema, the description does not provide enough context for an agent to fully understand the tool's behavior or expected results. It does not specify which SEO elements are analyzed, what the output looks like, or whether any preconditions exist, making it a bare-minimum description.

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

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

The only parameter, postId, is self-descriptive from its name, and the description ties it to 'a post'. However, with 0% schema description coverage, the description does not compensate by explaining the parameter's expected format, range, or that it is the WordPress post ID. The schema alone provides the type and requirement but little semantic context.

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

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

The description uses a specific verb ('Analyze') and clearly identifies the resource ('SEO elements') and target ('a post'). It is distinct from sibling tools that set or update SEO metadata, though 'SEO elements' remains somewhat vague without enumerating what those elements are.

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_set_seo_meta or wordpress_set_og_tags. The intended use is only implied by the word 'Analyze' and is not explicitly scoped or contrasted with other tools.

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

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

With no annotations present, the description carries the full burden of behavioral disclosure. 'Assign a menu to a theme location' implies a write operation but fails to disclose whether an existing menu at that location is replaced, what permissions are required, or what the return value is.

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

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

The description is a single, front-loaded sentence with zero filler words. Every word earns its place, and the structure is ideal for quick parsing by an agent.

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

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

Although the tool is simple (2 required params, no output schema), the absence of annotations and the 0% parameter coverage leave important gaps: the agent cannot know whether assigning overwrites an existing location assignment, what the response format is, or whether any preconditions apply.

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

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

Schema description coverage is 0%, so the description must compensate for the bare parameter names. It adds minimal context by identifying menuId as the menu and location as a theme location, but it does not explain valid location values, how to obtain a menuId, or any format/relationship details.

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 'Assign a menu to a theme location' uses a specific verb (assign) and identifies both the object (menu) and target (theme location), making the core action clear. However, it does not explicitly call out sibling tools like wordpress_get_menu_locations or wordpress_create_menu, leaving differentiation implicit rather than stated.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., menu must exist, location must be registered), when to prefer it over creating a new menu, or any exclusions, so the agent receives no contextual direction.

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

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

With no annotations, the description carries the full burden. It only says 'Assign role to user' and gives no details on whether the assignment overwrites existing roles, permission requirements, or side effects. This is a significant gap 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 brief and free of fluff, but it is under-specified. It is one sentence that states only the basic action, missing necessary details for effective tool 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 lack of annotations and output schema, the description is too sparse. It does not explain return values, when to use the tool, or behavioral implications, leaving an agent without enough context to invoke it confidently.

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

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

Schema description coverage is 0%, and the description does not explain the 'role' or 'userId' parameters. No parameter details, enums, or formats are provided, so the agent has no additional meaning 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?

The description 'Assign role to user' clearly states a specific verb and resource, distinguishing it from sibling tools like create_role or delete_role. It is unambiguous in its core action.

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

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

No guidance is provided about when to use this tool versus alternatives such as update_user or add_capability. The description does not mention any 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?

With no annotations provided, the description carries the full burden. It states the operation ('export database') but does not disclose any side effects, return format, output location, or prerequisites. The behavior is only minimally described, leaving the agent uncertain about 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 a single, front-loaded sentence with no unnecessary words. It efficiently conveys the core function and scope, making it easy for an agent to parse quickly.

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

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

The tool is simple (zero parameters), but the description lacks information about the export output, such as file format, location, or return value. Sibling tools like wordpress_list_backups provide some implicit context, but the description itself is not fully complete for predicting the outcome of a call.

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 properties, so the baseline is 4. The description adds meaning to the empty schema by specifying that the database is exported, which is the essential semantic context. No parameter documentation is needed.

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

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

The description 'Export database only' clearly states a specific verb (export) and resource (database), and the word 'only' directly distinguishes it from sibling tools like wordpress_full_backup and wordpress_backup_files. This makes the tool's purpose unmistakable.

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 explicitly state when to use this tool over alternatives, nor does it mention any prerequisites or exclusions. The 'only' suffix hints at a narrow scope but lacks direct comparison with other backup 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 must disclose behavioral traits. While 'backup files only' is clear, it doesn't explain the backup outcome (e.g., creates archive, where it's stored), any permissions or side effects, or return behavior. This is insufficient for an action that affects the file system.

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) and front-loaded, saying exactly what it does. There is no wasted text, though it is arguably too sparse to cover necessary details, which is a minor structural drawback.

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

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

The tool has no parameters, no output schema, and no annotations, so the description must compensate. 'Backup files only' is far too minimal to fully inform an agent about what the tool does, how to use it, or what to expect afterward. It leaves critical gaps about the backup process, storage, and how to access the backup.

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

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

With zero parameters, the baseline for parameter semantics is 4. The description adds meaning beyond the empty schema by clarifying the scope (files only, no database), which is the sole relevant semantic detail.

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

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

Description clearly states it backs up files only, using a specific verb ('Backup') and resource ('files'), and explicitly excludes the database. This distinguishes it from sibling tools like wordpress_backup_database and wordpress_full_backup, though it doesn't detail what 'files' includes (themes, plugins, uploads, etc.).

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

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

The description implicitly conveys when to use this tool (when a file-only backup is needed) but doesn't explicitly contrast it with alternatives or state exclusions. Given the sibling context, the agent can infer the use case, but there is no direct guidance such as 'use wordpress_backup_database for database-only backups'.

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 for behavioral disclosure. It only restates the core function without any details on permissions, failure modes, return values, or how the posts array should be structured. For a mutation tool, this is a significant transparency gap.

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

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

The description is a single, front-loaded sentence that is appropriately brief. However, it sacrifices needed detail for brevity, so while concise, it is not optimally 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 no output schema and no annotations, the description should at least explain what the 'posts' array should contain and what happens on success/failure. It lacks this essential context, making it incomplete for an agent to invoke 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 schema has only one parameter 'posts' (type array) with 0% description coverage, and the description adds no information about the parameter's structure or required fields. The description does not compensate for the bare schema, leaving the array format entirely unknown.

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

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

The description clearly states the tool's function: 'Create multiple posts in one operation' with a specific verb and resource, distinguishing it from single-post creation (wordpress_create_post) and bulk update/delete tools. The phrase 'batch content generation' reinforces the scope.

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

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

The description implies use for batch creation scenarios ('create multiple posts in one operation') and positions it as an alternative to single post creation, providing clear context. However, it does not explicitly state when not to use it or name alternatives, so it falls short of a 5.

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

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

With no annotations, the description carries the full burden of disclosing behavioral traits. While 'delete' clearly indicates destruction, it does not state irreversibility, potential impact on posts using the media, or any safety caveats. This is insufficient for a destructive operation with no annotation support.

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

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

The description is a single, concise sentence with no waste. It is appropriately short for the limited information it provides, though it lacks the structural detail that would make it fully effective.

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

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

For a delete operation with no annotations, no output schema, and a single under-explained parameter, the description is severely incomplete. It does not specify return values, error handling, permanence, or usage context, making it inadequate for an agent to invoke confidently.

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

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

The input schema has 0% description coverage and only one parameter, 'mediaIds'. The description does not explain what 'mediaIds' should contain (e.g., array of integers, UUIDs), its format, or any constraints, leaving the agent to infer from the parameter name alone. The description fails to compensate for the low schema coverage.

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

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

The description 'Delete multiple media files' clearly states the verb (delete), resource (media files), and the bulk aspect ('multiple'), which distinguishes it from the singular delete_media sibling. However, it does not elaborate on exactly how the deletion occurs (e.g., by an array of IDs), so it is specific but not fully detailed.

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

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

There is no guidance on when to use this tool versus the singular delete_media or other bulk alternatives. The description does not mention scenarios, prerequisites, or exclusions, leaving the agent without adequate selection cues beyond the name.

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

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

With no annotations provided, the description must disclose behavioral traits, but it fails to mention whether posts are permanently deleted or moved to trash, the role of the 'force' parameter, or any side effects. This is a destructive operation without safety context.

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

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

The description is a single, concise sentence that is easy to parse and front-loaded. However, it omits critical details, so it is concise 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?

The tool has no annotations and no output schema, so the description must compensate. It does not cover permanence, return values, or parameter semantics, making it inadequate for a destructive bulk operation.

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

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

The schema defines postIds and force with no descriptions, and schema description coverage is 0%. The description does not explain these parameters at all, leaving the agent without necessary information about their format or 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 clearly states the action (delete), the resource (posts), and the scope (multiple, one operation). This distinguishes it from sibling wordpress_delete_post, which targets a single 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?

There is no guidance on when to use this tool versus alternatives like wordpress_delete_post, nor any mention of prerequisites or exclusions. The description only states the function, leaving usage context to inference.

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

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

With no annotations, the description carries the full burden of disclosing behavioral traits. It states 'compress all images' implies a mutating, site-wide operation, but does not clarify whether originals are overwritten, whether it is reversible, or whether it may take a long time or require special permissions. This lacks necessary context for a potentially destructive bulk action.

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

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

The description is a single short sentence, but it contains redundancy: 'Bulk optimize images' and '(compress all images)' convey the same meaning. It is concise but not maximally efficient; 'Compress all images' would be equally clear and shorter.

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 site-wide bulk operation with no output schema and no annotations, the description is incomplete. It does not mention side effects (e.g., original file replacement), performance considerations, or any success/failure indicators. The description is too sparse to fully prepare an agent for the consequences of invoking this tool.

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

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

The tool has zero parameters, so the schema coverage is trivially 100%, and description is not required to explain parameter details. The description adds the scope 'all images', which effectively communicates the absence of filtering options, aligning with the 0-parameter baseline.

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

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

The description 'Bulk optimize images (compress all images)' clearly identifies the action (compress) and the resource (images), with an explicit scope ('all images'). It distinguishes from related tools like wordpress_convert_to_webp and wordpress_regenerate_thumbnails, though the word 'optimize' is slightly vague without the parenthetical.

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_convert_to_webp or wordpress_regenerate_thumbnails. It does not mention prerequisites, site-wide impact, or situations where a more targeted approach would be appropriate.

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

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

With no annotations, the description is the only source of behavioral details. It only states the core action and an efficiency claim, but does not disclose whether the operation is atomic, what happens on partial failure, permission requirements, or the response format. For a mutation tool, this is a significant gap.

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

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

The description is a single concise sentence that front-loads the key information ('Update multiple posts') and adds a small value statement. No wasted words.

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

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

The tool has one required parameter with an unclear structure, no output schema, and no annotations. The description does not explain how to construct the updates array or what response to expect, making it insufficient for an agent to invoke correctly. The minimal wording leaves critical invocation details unaddressed.

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 only defines 'updates' as an array with no item structure. The description says 'Update multiple posts' but does not clarify what the array should contain (e.g., IDs, field objects). With 0% schema coverage, the description needed to compensate but did not, leaving the parameter 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 says 'Update multiple posts in one operation' which clearly specifies the action (update) and resource (posts) while distinguishing it from singular update_post and bulk_create/bulk_delete siblings. The phrase 'multiple posts' makes the bulk scope explicit.

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?

'Efficient for batch modifications' implies the tool is intended for updating several posts at once, but it does not explicitly name alternatives like wordpress_update_post for single updates or exclude cases like needing different field structures. The guidance is implicit rather than explicit.

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

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

With no annotations, the description must fully disclose behavior. It states it 'checks' for updates, implying a read-only operation, but it does not mention whether this contacts external servers (e.g., WordPress.org API), what output format to expect (e.g., list of updates, count, or plain success), or any potential side effects. The description is too sparse to provide adequate behavioral transparency.

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

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

The description is a single, concise sentence that immediately states the tool's function. Every word contributes value, and there is no unnecessary elaboration. It is optimally sized 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?

While the tool is simple, the absence of an output schema means the description should explain what the agent should expect as a result. It does not specify whether the tool returns a list of available updates, a boolean, or a summary. Without this context, the agent cannot fully anticipate the tool's behavior, making the description 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?

The tool has zero parameters and the schema is empty, so there are no parameter semantics to explain. The baseline for 0 parameters is 4, and the description adds no parameter-related info, which is acceptable since none exist. It does not need to compensate for missing schema coverage because there are no inputs.

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

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

The description uses the specific verb 'check for available updates' and identifies the exact resources: WordPress core, plugins, and themes. This distinguishes it from sibling tools like get_version_info, which focuses on version information, and get_site_health, which is about overall health. The purpose is immediately 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?

There is no guidance on when to use this tool versus alternatives such as get_version_info or get_site_health. No when-to-use or when-not-to-use conditions are provided. The implied usage is for checking update availability, but no explicit context or exclusions are given.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It implies a read-only check but does not state that explicitly, nor does it mention side effects, error behavior, or what happens for invalid userId/capability values.

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

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

The description is a single, front-loaded sentence with no redundant wording. Every word contributes to conveying the core action, making it appropriately 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 simple two-parameter capability check, the description is minimally adequate, but it lacks any mention of return values or edge cases. Given the absence of an output schema and annotations, the description alone does not fully inform the agent about expected results.

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 parameter-level detail beyond the schema's names and types. The meaning of 'userId' and 'capability' is fairly obvious, but the tool does not compensate for the low coverage with any specifics.

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' uses a clear verb and names the core resource (user capability). It distinguishes itself from capability management tools like wordpress_add_capability and wordpress_remove_capability, though it does not state what result is returned (e.g., boolean).

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_get_capabilities or wordpress_assign_role. There is no mention of prerequisites, exclusions, or typical 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?

With no annotations, the description carries the full burden of behavioral disclosure. It indicates a mutating operation ('clean up') but does not explain whether data is permanently deleted, whether there are any safeguards, or what other effects may occur. The listed categories give some context, but the lack of detail on consequences is a significant gap for a cleanup 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, concise sentence that immediately states the tool's purpose. It is front-loaded and contains no redundant or unnecessary wording.

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

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

Given it is a simple tool with no parameters and no output schema, the description covers the main action and categories. However, it lacks behavioral context such as whether the cleanup is reversible, how long it might take, or what the tool returns after execution. Still, it is minimally adequate for a straightforward cleanup operation.

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

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

The tool has zero parameters, so per the baseline 4 applies. The description and schema are aligned, and there is no parameter information needed since there are none. The description does not need to add 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 that the tool cleans up the database, listing specific content types: revisions, auto-drafts, spam, and trash. This is a specific verb+resource combination. It is somewhat distinguishable from sibling tools like wordpress_optimize_database, but it does not explicitly name alternatives or contrast its scope.

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

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

The description implies usage when wanting to remove database clutter such as revisions, auto-drafts, spam, and trash. However, it provides no explicit guidance on when to use this tool versus alternatives like wordpress_optimize_database or wordpress_clear_cache, nor any exclusions or prerequisites.

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

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

No annotations are provided, so the description carries the full burden. It does identify the exact cache targets that will be cleared, which is useful. However, it doesn't disclose whether the operation is destructive, requires authentication, or has side effects like temporary performance impact after clearing. Scored 3.

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

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

One short sentence with no fluff. It front-loads the action and provides the essential specifics. Scored 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?

For a zero-parameter tool with no output schema, the description covers the core action well, naming the three cache types. It doesn't mention return values or effects, but given the simplicity, this is largely sufficient. However, a note about what happens after clearing (e.g., caches rebuild on demand) would improve completeness. Scored 4.

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 accepts zero parameters, and the input schema is complete. Baseline for zero-param tools is 4; the description doesn't need to add parameter semantics since there are none.

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

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

The description uses a specific verb ('Clear') and identifies the resource ('WordPress caches') with concrete subtypes (transients, object cache, page cache). This clearly distinguishes it from sibling tools like wordpress_optimize_database or wordpress_cleanup_database, which target database instead.

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 when-to-use guidance, no mention of alternatives, and no exclusions. It doesn't say that this is a maintenance operation versus a fix for stale data, nor when to prefer it over database optimization or rewrite flush. Scored 2.

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. The verb 'Clone' implies copying, but it does not explain potential side effects such as overwriting an existing staging site, data transfer scope, or permission requirements. This lack of detail could lead to misuse.

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 sentence, making it easy to read. However, it is too sparse to be considered well-structured; it lacks additional sentences that could add value, even though the single sentence is focused. It is appropriately short but underinformative.

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 minimal parameter detail, the description is insufficient for a correct and safe invocation. It does not clarify what the tool returns, what side effects occur, or how the staging environment is identified beyond the URL, leaving significant gaps for the agent.

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

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

The only parameter, 'stagingUrl', is self-named in the schema but completely undocumented in the description. The schema provides no description either (coverage 0%). The description does not explain what the URL should point to, whether it is the source or destination, or what format is expected.

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

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

The description states a clear action ('Clone') and a specific target ('WordPress') and destination ('staging environment'), which conveys the core purpose. It stands apart from sibling tools like backup or restore, but does not specify whether it clones files, database, or both, so it is not fully explicit about the scope.

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

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

No guidance is provided on when to use this tool instead of alternatives such as wordpress_full_backup, wordpress_restore_backup, or wordpress_import_content. There are no mentions of prerequisites, configuration steps, or scenarios where staging cloning 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 carries the full burden of behavioral disclosure. It simply says 'Convert image to WebP format' without explaining whether the original file is replaced, whether a new media item is created, whether the operation is reversible, or what side effects occur. This is a significant gap 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 a single sentence with no filler words. It gets straight to the point. Every word is necessary, and there is no redundant information.

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

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

For a tool with one parameter, no output schema, and no annotations, the description is still incomplete. It doesn't state what the result of the conversion is (e.g., success message, new URL) or describe any side effects. Users would need to guess whether the original media is replaced or a new file is created. This falls short of a minimum viable description.

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

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

The input schema exposes one required parameter, mediaId (number), but the description does not explain what mediaId is or how it relates to the conversion. Schema coverage is 0%, and the description only says 'image' without connecting it to the parameter. The name mediaId is somewhat self-explanatory, but the description adds no explicit 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?

The description uses a specific verb 'Convert' and resource 'image', and specifies the target format 'WebP'. It clearly states the tool's function. However, it doesn't explicitly differentiate from sibling tools like wordpress_bulk_optimize_images, which may also involve WebP conversion, so it loses a point for lacking explicit distinction.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., supported input formats), whether it's for single-image conversion, or any reference to other tools. There is no 'use this when...' or exclusionary context.

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

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

With no annotations provided, the description must disclose behavioral traits. It only restates the operation name without addressing potential side effects like overwriting existing files, creating directories, or handling permission errors. This leaves the agent with an incomplete behavioral model.

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 that is immediately clear and free of filler. It is efficient, though it lacks additional structure or context that would make it 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?

For a file operation with no annotations, no output schema, and no parameter descriptions, this description is severely under-specified. It does not mention return values, error conditions, path resolution, or overwrite behavior, leaving the agent with insufficient information to invoke the tool confidently.

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

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

The input schema has two parameters (source, destination) with no descriptions, and schema description coverage is 0%. The description does not explain what these parameters represent (e.g., relative paths, URLs, file names) or any expected format, so the agent has no semantic guidance beyond the parameter names.

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

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

The description clearly states the action ('Copy'), the resource ('file'), and the destination ('another location within WordPress'). This differentiates it from sibling tools like wordpress_move_file (which moves rather than copies) and wordpress_delete_file.

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_move_file or wordpress_write_file. There is no mention of context, prerequisites, or when a copy would be preferred over a move.

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 hierarchical support, but does not disclose side effects, permission requirements, or behavior on duplicate names. This is minimal disclosure 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 a single concise sentence with no wasted words. It efficiently states the core purpose and a relevant taxonomy trait.

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

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

For a create tool with no annotations, no output schema, and minimal parameters, the description is too sparse. It omits return value details, requirements, and how 'hierarchical support' is actually exercised given the only parameter is 'name'.

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 'name' parameter beyond implying it is the category name. The phrase 'hierarchical support' does not clarify parameter meaning, especially since the schema only includes 'name' and no parent 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 clearly states the action (create) and the resource (category), with 'hierarchical support' adding a useful hint. However, it does not explicitly differentiate from sibling tools like wordpress_create_tag, even though the category resource is distinct.

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

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

No guidance is given on when to use this tool versus alternatives, nor are any prerequisites or conditions mentioned. The phrase 'hierarchical support' is a feature description, not actionable usage guidance.

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

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

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It does not mention whether an existing child theme is overwritten, whether files are created, what permissions are required, or any side effects. The description only restates the basic action without revealing process or 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 a single, concise sentence that is front-loaded with the verb and resource. There is no unnecessary information, and it is immediately understandable.

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

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

For a creation operation with no annotations and no output schema, the description is too sparse. It does not explain what the tool returns after creation, whether it activates the child theme, what happens if the parent theme does not exist, or how it handles naming collisions. The simple statement is not enough for an agent to use the tool correctly without additional assumptions.

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

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

Schema description coverage is 0% and the description does not explain the parameters beyond implying 'parentTheme' is the source theme and 'childName' is the resulting name. It does not clarify that these are slugs, format constraints, or how they relate to the WordPress filesystem. The description adds minimal value beyond the parameter names.

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

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

The description clearly states the action ('Create'), the resource ('a child theme'), and the source ('from a parent theme'). This distinguishes it from sibling theme operations like activating or deleting themes, and is more specific than the tool name alone.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites (e.g., parent theme must exist), and no mention of when not to use it. The description is a simple statement of the action with no usage context.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does not mention that the operation is a write, requires authentication, validates the post, or returns the created comment object.

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

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

The description is a single, front-loaded sentence with no wasted words, making it easy to parse.

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

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

The tool is simple, but the description omits any mention of return values, error cases, or permissions. It is minimally viable but lacks helpful context for an agent.

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

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

Schema description coverage is 0%, and the description adds no meaning beyond the parameter names. It does not explain that postId is the target post's ID or that content is the comment body text.

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

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

The description uses the specific verb 'Create' and identifies the resource 'comment on a post,' clearly distinguishing it from sibling tools like get_comments, update_comment, and delete_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?

The description provides no guidance on when to use this tool versus alternatives or any prerequisites (e.g., valid post ID). It does not mention that updating existing comments requires the update_comment 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only restates the basic action without revealing side effects, required permissions, duplicate name handling, or return values. This is a significant gap for a create 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, front-loaded sentence that is easy to parse, but it is under-specified given the absence of annotations and schema parameter descriptions. While concise, it sacrifices necessary 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?

Given the tool's simplicity (1 parameter, no output schema), the description is insufficiently complete. It omits usage context, such as whether the menu is immediately available, how it relates to menu locations, or what the tool returns upon success.

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 a single 'name' parameter but lacks any description, and the description does not mention the parameter at all. With 0% schema description coverage, the documentation fails to explain the expected format, uniqueness requirements, or meaning of 'name'.

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

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

The description clearly states the specific action and resource: 'Create a new navigation menu'. It distinguishes this tool from siblings like create_menu_item (creates items, not menus), get_menus, and delete_menu, 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. It does not mention prerequisites, typical scenarios, or exclusions compared to sibling tools like create_menu_item or assign_menu_to_location, which are relevant for menu management.

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 merely states 'Add an item,' implying a write operation, but does not disclose whether an existing menu is required, how the 'menus' parameter is used, whether the operation is idempotent, or what response to expect. This is minimal and lacks meaningful behavioral detail.

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

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

The description is a single, concise sentence with no filler, but it is too under-specified to be genuinely helpful. It is not tautological, but it sacrifices essential detail for brevity. The structure is acceptable, but the content is minimal.

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 parameters, no annotations, no output schema, and a 0% schema description coverage, the one-sentence description is completely inadequate. It does not explain the parameters, the required input format, or the expected outcome, leaving the agent without sufficient context to call 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?

Schema description coverage is 0%, and the description does not explain the two parameters ('menus' and 'title'). The agent cannot infer that 'menus' likely refers to a menu ID, nor how 'title' is used. The description completely fails to compensate for the undocumented schema, making parameter usage unclear.

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 ('Add') and resource ('an item to a navigation menu'), using a specific verb+resource pattern. It implicitly distinguishes itself from siblings like wordpress_create_menu (creating the menu itself) and wordpress_update_menu_item (modifying an existing item). 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 is provided on when to use this tool versus alternatives such as wordpress_create_menu or wordpress_update_menu_item. The description does not mention any prerequisites, exclusions, or alternative conditions, leaving the agent without context for selection.

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

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

With no annotations provided, the description must fully disclose behavioral traits, but it does not. It fails to mention permissions, whether the page is published as draft, what happens with hierarchy, or the return value. The phrase 'hierarchy support' is an unsubstantiated claim since the schema only accepts title and content.

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

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

The description is a single, front-loaded sentence with no redundant content. The phrase 'with hierarchy support' is vague and arguably wastes words, but overall the structure is appropriately 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 simple two-parameter creation tool, the description is still incomplete. It lacks parameter semantics, behavioral details, expected output, and an explanation of 'hierarchy support.' The absence of annotations and output schema heightens the need for a more comprehensive description.

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

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

Schema description coverage is 0%, so the description should compensate by explaining parameters, but it does not. The field names 'title' and 'content' are self-explanatory, yet the description adds no extra meaning and 'hierarchy support' does not map to any schema property, potentially misleading the agent.

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 a new WordPress page') and the resource, distinguishing it from post creation and page updates/deletions. However, 'with hierarchy support' is vague and does not clarify how hierarchy is implemented, slightly muddying the 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 intended use is implied by the tool name and description (creating pages), but there is no explicit guidance on when to use this tool versus alternatives like wordpress_create_post or wordpress_update_page. No 'when' or 'when not' conditions 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 carries the full burden of behavioral disclosure. It only says 'Create a new WordPress post' and does not state whether the post is created as a draft or published immediately, what permissions are required, or any side effects. The phrase 'full control over all post properties' actively misleads because the schema restricts input to title and content.

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

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

The description is a single, front-loaded sentence, but the phrase 'with full control over all post properties' is both unnecessary and inaccurate. It adds noise rather than value, so while short, it is not fully concise in the sense of every word earning its place.

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

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

The tool has no output schema and no annotations, and the description does not explain return values, post status, error handling, or any other behavioral context. For a WordPress post creation tool, this is incomplete, even though the input schema itself is simple.

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 meaningful parameter guidance. Worse, 'full control over all post properties' contradicts the actual schema, which only accepts title and content, making the parameter semantics actively misleading rather than helpful.

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 and resource ('Create a new WordPress post'), and this distinguishes it from siblings like wordpress_update_post, wordpress_publish_post, and wordpress_create_page. However, the phrase 'full control over all post properties' is misleading given the schema only exposes title and content, so the purpose is slightly overclaimed.

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_schedule_post, wordpress_publish_post, or wordpress_bulk_create_posts. No context is given 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?

With no annotations, the description must convey behavioral details, but it only states the basic action. It does not disclose whether existing redirects are overwritten, required permissions, input validation, or side effects, which is a significant gap 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 a single concise sentence with no unnecessary words, making it easy to parse. However, the extreme brevity sacrifices useful detail, though that is more a completeness issue than a structural flaw.

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 annotations, output schema, and parameter descriptions, this one-liner is incomplete. It fails to provide essential information about how to use the tool, expected behavior, or return values, leaving the agent under-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 'source' and 'destination' parameters. The mention of status codes is not mapped to any schema field, creating ambiguity about how the redirect type is selected.

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

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

The description clearly identifies the action ('Create') and resource ('URL redirect'), and specifies supported status codes (301, 302, 307). This distinguishes it from sibling tools like get_redirects and delete_redirect by verb, though it does not explicitly name alternatives.

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

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

No guidance is given about when to use this tool versus alternatives, prerequisites, or exclusions. The agent is left to infer the context solely from the word 'Create'.

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 disclose behavioral traits. It does not mention permissions, side effects, duplicate handling, content format, or return values. For a mutating operation, this is a complete lack of 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 extremely concise, but it is under-specified rather than appropriately sized. It is a single fragment that does not provide enough information to be considered well-structured or valuable.

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

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

Although the tool has only two parameters and no output schema, the description is too minimal for a create operation. It does not explain what a reusable block is, what content format is expected, or any prerequisites. It is incomplete for practical use.

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

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

Schema description coverage is 0% and the description does not explain the meaning or expected format of 'title' and 'content'. While the names are somewhat self-evident, the content type (HTML, block markup, etc.) is unspecified, and the description fails to compensate for the schema's lack of detail.

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' has a specific verb ('Create') and resource ('reusable block'), clearly distinguishing it from sibling tools like get/update/delete_reusable_block. It unambiguously states the tool's function.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives. It does not mention related tools like wordpress_update_reusable_block or wordpress_get_reusable_blocks. Usage is only implied by the tool name and action.

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 what happens if the role already exists, what capabilities the new role has initially, or any permission requirements. This is a mutation operation with significant unspecified behavior.

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

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

The description is a single, efficiently worded sentence. It contains no superfluous text and is front-loaded with the key purpose.

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

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

Given the tool is a mutation with no annotations, no output schema, and 0% schema documentation coverage, the description is too sparse. It provides the basic purpose but omits critical context like conflict behavior, initial capabilities, and response format, leaving the agent uncertain about invocation.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meaning. 'role' and 'displayName' are self-explanatory to a degree, but the description adds no clarification on formats, uniqueness constraints, or how these parameters relate to WordPress role registration.

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 target resource ('a custom user role'), which is specific and easily distinguished from sibling tools like get_roles, delete_role, and 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 is provided on when to use this tool versus alternatives, nor any exclusions or prerequisites. The description does not mention scenarios where creating a role is appropriate or how it relates to capability management.

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

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

With no annotations provided, the description carries full responsibility for disclosing behavioral traits. It only says 'Create a new tag', which implies a mutation but gives no details about permissions, duplicate handling, side effects, or return behavior. This is a significant transparency gap.

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

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

The description is extremely concise (one short sentence), but this is under-specification, not effective conciseness. It lacks any structure or elaboration that would make it useful, and every word merely echoes the tool name.

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

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

This is a simple tool with one parameter, but the description still fails to provide essential context. It omits any information about the parameter, behavior, or alternatives. Combined with the lack of annotations and output schema, the description is almost completely uninformative.

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

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

Schema description coverage is 0%, so the description must compensate by explaining parameter meaning. It does not mention the 'name' parameter at all, leaving the single required field entirely undocumented. No value is added beyond the raw 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 'Create a new tag' is essentially a verbatim restatement of the tool name 'wordpress_create_tag'. It does identify the resource (tag) but adds no new information beyond the name, making it a tautology. It does not distinguish this tool from siblings beyond what the name already conveys.

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_create_category or wordpress_create_term. It does not mention prerequisites, use cases, or exclusions, leaving the agent without contextual 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?

With no annotations, the description carries full responsibility for disclosing behavioral traits. It only states the basic action and does not mention side effects, error conditions, permissions, or behavior on duplicate terms. This is a minimal disclosure with no added 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 a single concise sentence with no unnecessary words. It is appropriately front-loaded, but the extreme brevity comes at the cost of omitting useful contextual information. It is concise, but not fully 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?

For a tool with two required parameters and no annotations or output schema, the description is lacking. It fails to explain the meaning of 'term', the taxonomy parameter, or any constraints. The description is too sparse to be considered complete for an agent to use it reliably.

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

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

Schema description coverage is 0%, so the description must compensate. It implies 'taxonomy' is the target taxonomy but provides no explanation of what 'name' represents or the expected format/value for either parameter. The description adds little beyond the schema's basic 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 ('Create a new term') and the resource ('taxonomy'), using a specific verb. However, it does not explicitly differentiate from sibling tools like create_category or create_tag, which likely serve similar purposes.

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

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

No guidance is provided on when to use this tool versus alternatives such as create_category, create_tag, or update_term. The description gives no context on prerequisites, taxonomy types, or scenarios where this tool is preferred.

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 carry the burden. It discloses that it creates a user, but not whether it requires admin privileges, what happens with duplicate usernames/emails, how the password is processed, or what the response contains. The vague 'with roles' raises more questions than it answers.

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, but it sacrifices essential information. It is minimally acceptable in size, yet the omission of role-related details means it is not fully effective.

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

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

Given a simple 3-parameter create tool, the description lacks any info on return value, error conditions, authentication, or how roles (mentioned) are actually assigned. Sibling tools like wordpress_assign_role exist, so the relationship should be clarified. Incomplete for a mutation tool with no annotations or output schema.

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

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

Schema has no descriptions, and the description does not clarify the meaning or constraints of username/email/password. It introduces 'roles' as a concept that is not present in the schema, possibly misleading. With 0% schema coverage, this is a critical gap.

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

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

Clearly states a specific action (create) and resource (WordPress user). Distinguishes from siblings like update_user/delete_user. However, 'with roles' suggests role assignment within this tool, which is not reflected in the schema, creating slight 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 on when to use this tool versus alternatives. Does not mention that role assignment may be handled by wordpress_assign_role, nor any prerequisites like existing authentication. The description only states the action itself.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It merely restates the action without explaining side effects, required permissions, reversibility, or what happens to the plugin after deactivation.

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

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

The description is a single concise sentence with no unnecessary words, but it is under-specified. While brevity is positive, it comes at the cost of providing meaningful detail beyond the tool name.

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

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

For a mutation tool with no annotations, no output schema, and one undocumented parameter, the description is inadequate. It lacks prerequisites, parameter format details, and any explanation of effects, making the tool difficult to use correctly in context.

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

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

The input schema has one required parameter 'plugin' (string) with no description, and schema description coverage is 0%. The description does not explain what value to pass (e.g., plugin slug, file path, display name), leaving the agent without enough information to invoke the tool 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 'Deactivate a plugin' clearly states the action (deactivate) and resource (plugin). It is specific but essentially restates the tool name without differentiating it from siblings like activate_plugin or delete_plugin, though the meaning 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?

The description provides no guidance on when to use this tool, when not to use it, or alternatives. It only states the basic action with no context about prerequisites or relation to other plugin management tools.

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

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

Annotations are absent, so the description carries the full burden. 'Delete a backup file' implies destructive behavior but does not disclose whether deletion is permanent, irreversible, or affects related data. No mention of permissions, confirmation, 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 a single, front-loaded sentence with no fluff. It is efficient for a simple tool, though it sacrifices important detail. Still, it earns its place by being concise 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?

With one parameter and no output schema, the description is relatively simple, but it lacks essential context about the permanence of deletion, expected results, and how the backupId is defined. This gap could lead to incorrect tool usage.

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

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

Schema description coverage is 0% and the description does not explain the backupId parameter at all. It gives no indication of what backupId refers to or how to obtain it from tools like wordpress_list_backups, forcing the agent to guess at 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 uses a clear verb ('Delete') and resource ('a backup file'), which unambiguously identifies the action. It distinguishes itself from sibling backup tools like list_backups and restore_backup by clearly indicating it performs deletion.

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

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

No guidance is provided about when to use this tool versus alternatives such as list_backups or restore_backup. The description lacks context on prerequisites or use cases, leaving the agent without direction on tool selection.

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

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

There are no annotations, so the description must fully disclose behavior. It merely says 'Delete a category' and omits critical behavioral details such as whether deletion is permanent, whether the 'force' parameter is required for non-empty categories, or what happens to associated posts. This leaves the agent without vital 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 extremely short, containing only three words. While it has no wasted words, the extreme brevity is under-specification rather than efficient structure. There is no sentence structure or logical flow to guide the agent.

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

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

Given the tool's potential side effects (deleting a category), the description is drastically incomplete. There is no output schema, no annotations, and no explanation of the return value, error conditions, or impact on content. This is inadequate 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 description coverage is 0%, and the description does not mention either parameter. The schema only provides types (number, boolean) but no meaning for categoryId or force. The description offers no insight into how these parameters affect the deletion.

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' directly states the tool's action and target resource. However, it essentially restates the tool name 'wordpress_delete_category' without adding any additional information, such as scope, conditions, or side effects. This is a tautological restatement, so it only clarifies the obvious.

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_update_category or wordpress_get_categories. There are no prerequisites, exclusions, or references to related operations. The agent receives no context for tool selection.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Delete a comment' implies destructive action but does not clarify whether deletion is permanent, moves to trash, or what the 'force' parameter does. It also omits permission requirements and any cascading 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 short sentence, making it concise and front-loaded. However, it is so sparse that it borders on under-specification rather than effective conciseness; it conveys minimal information but does not waste words.

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

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

Given the simple tool signature, the description is not complete enough. It omits crucial details about the 'force' parameter, return values, and whether the delete is soft or hard. This is particularly problematic because there are no annotations or output schema to fill the gaps.

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

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

Schema description coverage is 0%, and the description adds no explanation of the two required parameters. The parameter names (commentId, force) give some hint, but the semantics of 'force' remain ambiguous, and the description does not compensate for the lack of schema documentation.

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

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

The description 'Delete a comment' uses a clear verb and resource, and it distinguishes from sibling tools like get_comments, create_comment, and update_comment by indicating the delete operation. However, it lacks any additional context such as scope or conditions, so it is slightly below a top score.

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

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

There is no guidance on when to use this tool instead of alternatives, nor any mention of prerequisites or exclusions. The description simply states the action, leaving the agent to infer 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 carries the full burden of behavioral disclosure. It mentions 'optional backup' which is a useful safety feature, but it does not explain whether deletion is permanent, how backup works, where files are deleted from, or if any permissions are required. 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 very short and front-loaded, which is efficient, but it reads as a fragment rather than a well-structured sentence. It is not overly verbose, yet it sacrifices clarity for brevity. It earns a middle score for being concise but lacking full grammatical construction.

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 (2 params, no output schema), the description should still provide context on what 'file' means, the backup behavior, and any side effects. The description does not explain the file system scope, backup location, or return values. For a destructive tool, this is notably incomplete.

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

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

Schema coverage is 0%, and the description provides minimal parameter context. It implies 'backup' relates to the createBackup parameter, but the phrase 'optional backup' conflicts with the schema's 'required' list, which marks createBackup as required. The 'path' parameter is not mentioned at all. The description adds little value beyond the raw 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 action 'Delete file' with the additional nuance 'with optional backup'. This distinguishes it from sibling tools like copy, move, or write. However, it does not specify what type of file (e.g., theme file, plugin file, arbitrary WordPress file), 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 copy, move, or write. It also lacks any mention of prerequisites, safety warnings, or contexts where deletion is appropriate. The agent is left without decision-making criteria.

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

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

With no annotations, the description must convey behavioral traits, but it only states 'Delete a media file from library'. It does not disclose whether deletion is permanent, whether the 'force' parameter bypasses safeguards, or what side effects occur for associated data.

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

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

The description is a single, clear, front-loaded sentence with no unnecessary words. It is efficient, though it under-specifies parameter semantics; conciseness itself is strong.

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

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

The tool is destructive, has two required parameters, no annotations, and no output schema. The description provides no context about side effects, the role of 'force', or how this differs from bulk deletion, making it incomplete for safe invocation.

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

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

Schema description coverage is 0%, and the description does not mention either parameter (mediaId or force). The agent must rely entirely on parameter names, which is insufficient for understanding required behavior and 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 uses the specific verb 'Delete' and identifies the resource as 'a media file from library', making the core action clear. It does not explicitly differentiate from sibling tools like wordpress_bulk_delete_media, so it falls short of a perfect score.

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

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

No guidance is given on when to use this tool versus alternatives such as bulk delete, nor are any prerequisites or selection criteria mentioned. The description simply states the action without contextualizing its 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?

There are no annotations, so the description must carry the burden of behavioral disclosure. While 'Delete' implies destruction, it does not explain whether deleting a menu cascades to menu items, whether the operation is reversible, or what permissions are required. The 'force' parameter's behavioral role is also unexplained.

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 is well-structured for readability but is overly terse given the tool's destructive nature and reliance on parameter clarification.

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

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

For a destructive tool with two required parameters, no annotations, and no output schema, this description is critically incomplete. It omits the meaning of 'force', the effects on related menu items, and any usage caveats, leaving the agent without essential context to invoke the tool 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 to the parameters. 'menuId' and 'force' remain unexplained, especially 'force', which is ambiguous. The description must compensate for the schema gap but fails to do so.

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' uses a specific verb (delete) and resource (navigation menu), clearly distinguishing it from sibling tools like wordpress_delete_menu_item and wordpress_delete_page. It directly states the tool's core function without 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 about when to use this tool versus alternatives such as deleting menu items, deleting pages, or other delete operations. The description gives no context about prerequisites or conditions 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states 'delete' without mentioning irreversibility, the effect of 'force', or any side effects such as cascading deletions. This is minimal and lacks valuable context.

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

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

The description is a single, front-loaded sentence with no superfluous words. It efficiently communicates the core action.

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

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

Given no annotations, no output schema, and two required parameters left unexplained, the description is underspecified. An agent cannot infer the meaning of 'force', potential prerequisites, or any confirmation of deletion, making the tool risky to invoke.

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 'itemId' or 'force'. The agent is left to guess what 'force' does or how 'itemId' relates to menu items, making correct invocation uncertain.

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' uses a specific verb and resource, clearly indicating the tool's function. It distinguishes itself from sibling tools like wordpress_delete_menu (which deletes an entire menu) and wordpress_update_menu_item.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor does it mention any prerequisites or contexts. It simply restates the action without explaining the role of the 'force' parameter or when a forced delete is needed.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It fails to explain key aspects such as whether deletion is permanent or moves to trash, the role of the 'force' parameter, or any side effects. This is a significant gap 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?

While the description is concise at three words, it is under-specified rather than appropriately sized. It lacks essential context that a deletion tool with a force parameter requires, so brevity works against clarity.

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

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

Given no output schema, no annotations, and two required parameters including a boolean 'force', the description is incomplete. It does not explain the return value, the effect of 'force', or any consequences, 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 adds no meaning beyond the parameter names. The agent must infer that 'pageId' is the page identifier and 'force' likely controls trash vs permanent deletion, but no explicit clarification is 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 'Delete a page' uses a specific verb and resource, clearly distinguishing this tool from sibling tools like wordpress_delete_post and wordpress_delete_media. It unambiguously states the operation performed.

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

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

No guidance is given on when to use this tool versus alternatives. There is no mention of scenarios, prerequisites, or exclusions, leaving the agent to infer usage solely from the name.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It mentions the deactivation prerequisite, which is helpful, but it says nothing about permanence, file removal, error conditions, or required permissions. For a destructive operation, this is insufficient.

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

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

The sentence is concise and front-loaded, avoiding unnecessary verbosity. However, it is so brief that it omits essential details about the parameter format, though the structure itself is clean 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 this is a mutation tool with no annotations and no output schema, the description should compensate by explaining the parameter format, side effects, and success criteria. It only covers the action and one prerequisite, leaving significant gaps for an agent to use it correctly.

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

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

The schema has one 'plugin' parameter with no description (0% coverage). The description merely repeats 'plugin' without clarifying whether it expects a slug, plugin file path, or display name. This is a critical gap that the description fails to address.

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 a plugin') with a specific resource, distinguishing it from sibling tools like activate_plugin or deactivate_plugin. The additional precondition ('must be deactivated first') further clarifies the tool's 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?

Provides a clear usage condition: the plugin must be deactivated first. This implies the correct workflow (deactivate before deleting) but does not explicitly mention when to use this versus alternatives like deactivate_plugin or get_plugin_status. Still, it offers useful context beyond a bare description.

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 behavioral burden. It explicitly discloses the critical behavior of the force parameter (permanent vs trash), which is valuable. However, it omits other potential traits like permission requirements, error handling, or irreversibility confirmation beyond 'permanently delete'.

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, concise sentence that is front-loaded with the core action ('Delete a post') and efficiently packs the conditional behavior. No wasted words, ideal for quick agent parsing.

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

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

For a simple two-parameter tool with no output schema, the description covers the essential operational behavior. It lacks some completeness (e.g., return values, error cases), but the minimal complexity makes this acceptable. The trash/permanent distinction is the most important contextual complexity and is addressed.

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

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

Schema description coverage is 0%, so the description must compensate. It effectively explains the force parameter's meaning (permanent vs trash), which adds essential semantics beyond the bare schema type. The postId parameter is self-explanatory, but the description does not explicitly label it as the target post ID.

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

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

The description uses a specific verb+resource ('Delete a post') and clearly distinguishes the two deletion modes (force=true permanent vs trash). This is unambiguous and implicitly differentiates from sibling tools like bulk_delete_posts and delete_page via the 'post' scope.

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

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

The description implies usage by context (single post deletion vs bulk or page deletion) but does not explicitly mention alternatives or when-not-to-use. There is no exclusionary guidance like 'use wordpress_bulk_delete_posts for multiple posts,' so guidance is only implied.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavioral traits. While 'Delete' implies a destructive action, the description does not state whether the deletion is permanent, whether it requires specific permissions, or what happens if the redirectId does not exist. 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 concise at three words, but the extreme brevity sacrifices necessary information. It is front-loaded with the action, yet lacks any elaboration on usage or behavior. While efficient in word count, the under-specification makes it less effective.

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

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

For a simple delete tool with one parameter, the description is incomplete. It does not mention the acceptable format of redirectId, any related side effects, or confirmation behavior. Without annotations or an output schema, the description should provide more context to fully support the agent, but it provides only the bare action.

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

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

Schema description coverage is 0%, and the description does not mention the 'redirectId' parameter at all. The schema provides only the name and type (number) with no additional context. The description fails to explain what the ID represents or how to obtain it, leaving the parameter semantics completely undocumented.

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 tool's action (delete) and resource (URL redirect). It is specific and distinguishes itself from sibling tools like wordpress_create_redirect and wordpress_get_redirects by explicitly indicating 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?

The description provides no guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. For example, it does not mention that redirectId must correspond to an existing redirect, or that this should be used only when a redirect is no longer needed.

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

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

With no annotations, the description is the sole source of behavioral disclosure, but it merely restates the tool's purpose. It does not mention that deletion is destructive and likely permanent, nor the role of the 'force' parameter.

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 with zero unnecessary words, but it is under-specified. It is a single sentence that could have been expanded with critical details while maintaining conciseness.

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

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

The tool deletes a reusable block with no output schema or annotations, and the description does not cover the effect of the operation, the significance of the force parameter, or any safety considerations. Incomplete for a destructive operation.

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

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

Schema description coverage is 0%, and the description does not explain the two required parameters (blockId, force). Without additional info, the agent cannot understand the force flag's 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 uses a specific verb ('Delete') and resource ('reusable block'), clearly distinguishing it from sibling delete tools for posts, pages, media, etc. It fully states the tool's function.

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

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

No guidance is provided on when to use this tool, when not to use it, or alternatives. It lacks information about prerequisites like the force parameter or whether blocks need to be trashed 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?

There are no annotations, and the description doesn't disclose behavioral traits such as irreversibility, whether built-in roles can be deleted, or what happens if the role is assigned to users. It only states the action without side effects or limitations.

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

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

The description is a single sentence of six words, front-loaded with the action, and contains no filler. It is appropriately sized for a simple tool, though other dimensions suffer from 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?

While the tool is simple, the description lacks essential context for a destructive operation: no mention of permanence, error conditions, or restrictions on which roles can be deleted. Given no annotations or output schema, this leaves the agent undersupplied.

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 a single 'role' string parameter with no description. The description doesn't explain what value 'role' expects (e.g., slug, name, ID) or how it relates to the 'custom user role' resource. With 0% schema coverage, the description fails to compensate.

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

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

The description uses the specific verb 'Delete' and identifies the resource as 'custom user role', which clearly distinguishes it from sibling tools like wordpress_create_role and wordpress_assign_role. The qualifier 'custom' adds specificity about the target role type.

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. It doesn't mention when to use this tool, prerequisites, or alternatives such as wordpress_get_roles or wordpress_remove_capability. The context of when to delete a custom role is absent.

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 of behavioral disclosure, but it only states the action without elaborating on consequences such as irreversibility, the effect of the 'force' parameter, or cascading impacts on associated objects. It adds no behavioral context beyond the tool name's implied deletion.

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, efficiently worded sentence with no redundancy. It is front-loaded with the action and resource, but it is so brief that it misses opportunities to include essential information without sacrificing clarity.

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

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

The tool is a destructive operation with no annotations, no output schema, and a required 'force' parameter that is unexplained. The description is far too sparse for an agent to safely execute the task, lacking critical context about the force flag and the term deletion's broader effects.

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

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

Schema description coverage is 0%, and the description does not explain any parameters. The schema lists taxonomy, termId, and force, but the description fails to clarify the meaning of 'force' or how the parameters interact. With three required parameters and no description, parameter semantics are entirely undeveloped.

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 term from a taxonomy' uses a specific verb ('delete') and resource ('term'), clearly indicating the action and scope. It distinguishes from sibling tools like create_term, update_term, and get_terms by specifying deletion, and the 'taxonomy' context separates it from delete_category/delete_tag.

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

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

No guidance is provided about when to use this tool versus alternatives such as delete_category or delete_tag. There is no mention of prerequisites, exclusions, or preferred scenarios, leaving the agent to infer usage solely from the action.

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 burden of behavioral disclosure. It does reveal one key limitation (cannot delete active theme), which is important. However, it does not mention whether deletion is permanent, what consequences arise (e.g., child themes), or the meaning of the 'force' parameter. The disclosure is minimal but not misleading.

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

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

The description is a single, concise sentence that front-loads the primary action and includes a key constraint. There is zero waste or irrelevant information; 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?

For a destructive operation with no annotations and no output schema, the description is incomplete. It omits information about what 'force' does, parameter formats, and any side effects. While the purpose is clear, the lack of behavioral detail and parameter semantics makes the description insufficient 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 input schema has zero description coverage, and the description does not explain either parameter ('stylesheet' or 'force'). The term 'cannot delete active theme' hints that 'force' might override a check, but it does not clarify parameter meaning or allowed values. The description fails to compensate for the lack of schema descriptions, leaving the agent with no semantic 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 tool's function: 'Delete a theme' with a specific resource and verb. It also adds a critical constraint ('cannot delete active theme') that distinguishes it from other theme actions like activation or retrieval, making it clear this is the deletion tool among the theme-related siblings.

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

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

The only usage guidance is the parenthetical 'cannot delete active theme', which implies the tool cannot be used on the active theme but does not explicitly state when to use this tool over alternatives. There is no mention of prerequisites like activating a different theme first, nor any exclusions for other resource types. The guidance is implied rather than explicit.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It does reveal a key side effect (content reassignment), which is valuable. However, it omits critical safety information such as irreversibility, permission requirements, or effects on other user-related data.

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

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

The description is a single, efficient sentence that front-loads the action. There is no filler or redundancy. Every word adds value.

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

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

Despite the low parameter count, this is a destructive operation with no annotations or output schema. The description does not mention irreversibility, prerequisites (e.g., the reassign user must exist), or error behavior. It captures the core action but lacks essential context for safe invocation.

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

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

Schema description coverage is 0% and the schema only lists two number parameters. The description hints at the meaning of 'reassign' ('to another user') but does not explain 'userId' or explicitly map each parameter to its role. The description only partially compensates for the missing schema descriptions.

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

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

The description clearly states the action ('Delete a user') and the resource (user). The parenthetical about reassigning content distinguishes it from simple deletion and aligns with the sibling tools (e.g., create_user, update_user). 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 explicit guidance on when to use this tool versus alternatives. There is no mention of prerequisites, exclusions, or comparison to similar tools like wordpress_assign_role or wordpress_update_user. The description only implies deletion 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?

The description only says 'Delete' without disclosing whether deletion is permanent, what the 'force' parameter does, or any required permissions. With no annotations, the description carries the full burden for behavioral disclosure, and it does not adequately address the destructive nature of the 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, front-loaded sentence with no unnecessary words. It is concise and easy to parse, though it omits important details about parameters and behavior, making it slightly too terse for a fully useful description.

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

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

For a destructive mutation tool with no annotations, no output schema, and no parameter descriptions, the description is too sparse. It does not specify the role of 'force', the effect of deletion, or any warnings about reversibility. The low complexity of the tool does not excuse the lack of essential context.

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

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

The description does not explain the purpose of 'widgetId' or 'force'. The input schema also lacks descriptions (0% coverage), so the agent has no information about what these parameters mean or how to set them. The description adds no value beyond the raw 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 action (delete), the object (widget), and the location (from a sidebar). It is specific enough to distinguish it from sibling tools like wordpress_update_widget or wordpress_get_widgets.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention that to modify a widget one should use wordpress_update_widget, or that to retrieve widgets one should use wordpress_get_widgets. Without such context, the agent is left without decision 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?

With no annotations, the description must fully disclose behavior, but it only says 'duplicate' without explaining what is copied (content, metadata, media), whether the duplicate is a draft, if any permissions are needed, or what the response looks like. This leaves significant ambiguity.

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

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

The description is a single concise sentence with no wasted words, but it is so sparse that it borders on under-specification. It could include more useful details without becoming wordy.

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, no annotations, no output schema, and 0% schema coverage, the description should explain the duplication semantics, return value, and required fields. It only covers a fragment of the necessary context.

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

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

The description mentions 'new title' but incorrectly labels it as optional when the schema marks newTitle as required. It fails to explain postId at all, and with 0% schema coverage, this misleading and sparse parameter information is inadequate.

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'), the resource ('an existing post'), and the optional parameter ('new title'). This distinguishes it from create/update/delete operations, though 'optional new title' contradicts the schema requirement that newTitle is required.

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

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

No guidance is given on when to use this tool compared to alternatives like wordpress_create_post or wordpress_update_post. There is no mention of use cases, 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?

With no annotations, the description must disclose behavioral traits, but it only repeats the action. It fails to explain how the tool decides between enabling and disabling given the empty parameter schema, nor does it mention effects on site access or whether it toggles state. This is a serious transparency gap.

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

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

The description is a single concise sentence, front-loaded with the verb and resource, with no filler words. However, its brevity contributes to the under-specification of behavior, so it doesn't earn a top 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?

Despite having no parameters and no output schema, the tool's behavior is not adequately specified because the enable/disable dichotomy is unresolved. The description lacks any mention of preconditions, side effects, or return values, making it insufficient 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 zero parameters, so the description must clarify the tool's operation, but it doesn't. The phrase 'Enable or disable' implies a choice that no parameter can express, leaving ambiguous whether the tool toggles the current state or requires some external context. The empty schema baseline is 4, but the misleading implication drops the score.

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

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

The description uses a specific verb phrase 'Enable or disable' with a clear resource 'WordPress maintenance mode,' identifying exactly what the tool does. The tool is unique among the large sibling set; no other tool mentions maintenance mode, so it is clearly distinguishable.

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 enable vs disable maintenance mode, or when this tool should be preferred over any alternative. The description only restates the function, leaving usage decisions entirely to the agent.

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

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

There are no annotations, so the description must carry the full burden of behavioral disclosure. It only says 'process and execute,' which repeats the tool name without revealing potential side effects, return format, error behavior, or security implications of running arbitrary shortcode. The description adds no information beyond the name itself, making it dangerously opaque for a tool that executes code.

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 contains redundant wording: 'process and execute' are near-synonyms, so the first word adds no value. The front-loading is fine, but the phrasing could be more direct and information-dense. For a one-line description, it's not egregiously bloated, but it could be improved with more specific language.

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

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

This is a minimal description for a tool with no annotations, no output schema, and one opaque parameter. A shortcode execution tool can have arbitrary side effects and output HTML, so the description should explain the required format, expected return value, and potential risks. None of this is present, making the description grossly incomplete for an agent to invoke it confidently.

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

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

The input schema has a single required `content` parameter with no description, and schema description coverage is 0%. The description does not mention the parameter at all, offering no guidance on what `content` should contain (e.g., full shortcode string like `[gallery]`). The tool name hints that it's related to shortcodes, but the description fails to compensate for the schema's lack of detail.

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

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

The description uses the verb 'execute' and identifies the resource 'shortcode string', which clearly indicates the tool runs a shortcode. It distinguishes from sibling tools like wordpress_list_shortcodes and wordpress_shortcode_exists because execution is different from listing or checking existence. However, 'process' is vague filler that slightly reduces precision.

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 usage context, no mention of when to use this tool relative to alternatives, and no exclusions. It simply states what the tool does, leaving the agent to infer that it's for executing shortcodes. No alternative tools are referenced, such as wordpress_list_shortcodes for discovering available shortcodes.

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. It discloses a key behavioral constraint—only SELECT, SHOW, DESCRIBE, and EXPLAIN are permitted—effectively making it a read-only SQL executor. However, it does not mention result formatting, error behavior, or permission requirements.

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

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

One short sentence, front-loaded with the action and immediately followed by the safety constraint. No wasted words and the most important information is presented first.

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, the description is adequate but incomplete: it lacks any mention of the return value (result set) and error handling. The safety restriction is helpful, but the absence of output schema behavior leaves some ambiguity about what the agent can expect.

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

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

The single 'query' parameter is named clearly, and the description adds meaning by restricting acceptable query types. It does not, however, provide format details (e.g., whether semicolons are allowed, if multiple statements are supported, or if a trailing semicolon is required).

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

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

The description clearly states the action (Execute) and object (SQL query), and explicitly enumerates the allowed statement types (SELECT, SHOW, DESCRIBE, EXPLAIN), distinguishing it from all other WordPress tools that perform specific operations rather than raw SQL execution.

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 it is for safe, read-only custom SQL queries via the 'only for safety' clause, but it does not explicitly state when to use this tool versus the many specialized WordPress tools (e.g., get_posts, list_tables) or mention any 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?

No annotations are provided, so the description carries the full burden. It only says 'Export posts/pages as WordPress XML' but does not disclose behavioral traits like whether it's read-only, what the output format looks like (e.g., file download vs. string), or if any permissions are needed. This is a minimal statement with no side-effect or return-value 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, front-loaded sentence without redundant words or repetition of the tool name. It is appropriately terse for a simple tool, though it could potentially add a bit more structure 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?

The tool has no output schema, so the description should explain what the tool returns or produces. It doesn't say whether the XML is returned directly, saved to a file, or otherwise delivered. Given the minimal context and no annotations, the description is incomplete for an agent to know the invocation result.

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

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

With zero parameters, the schema already provides full coverage (100%). The baseline for 0-param tools is 4, and the description adds no unnecessary parameter details. No additional semantic explanation is needed.

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

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

The description clearly states an export operation on 'posts/pages' with output format 'WordPress XML'. The verb 'Export' and resource 'posts/pages' make the purpose specific. However, it doesn't fully distinguish from backup/import siblings or specify scope (e.g., all posts/pages or selected).

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 full_backup or import_content. It doesn't mention any prerequisites, exclusions, or context where this tool is preferred.

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 burden of behavioral disclosure. It does state the returned metadata fields, but it does not explicitly confirm it is a read-only operation, describe error behavior, or clarify whether 'path' refers to absolute server paths or WordPress media paths. The verb 'Get' implies non-mutating, but deeper context is absent.

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

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

The description is a single, concise sentence that is front-loaded with the action and resource. It contains zero redundant information and is appropriately brief for a simple metadata tool.

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

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

Despite having only one parameter and no output schema, the description is incomplete: it does not define the path parameter, does not describe the return value structure, and offers no usage context. An agent would be unsure how to specify the path or interpret the result beyond the three listed fields.

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 'path' parameter. While the name is self-explanatory, the description fails to specify the expected format (absolute vs relative, file vs directory), which is essential 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 uses the specific verb 'Get' with the resource 'file information' and lists the concrete data points (size, modified date, permissions). This clearly distinguishes it from sibling tools like wordpress_read_file (which reads file contents) and wordpress_list_files (which lists files).

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

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

No guidance is provided on when to use this tool versus alternatives such as wordpress_read_file or wordpress_list_files. There is no mention of prerequisites, path types, or exclusion criteria.

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

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

No annotations are provided, so the description should disclose behavioral traits such as side effects, permission requirements, or state changes. The description only states the action and an implied benefit; it does not mention that flushing rewrite rules modifies WordPress state, may be a heavier operation, or could briefly affect the site. This leaves the agent without important context about 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 a single short sentence that front-loads the action ('Flush') and the target resource. Every word earns its place, and there is no unnecessary detail. It is concise while still conveying purpose and use case.

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, single action), the description is largely complete. It explains what it does and why. However, a mention of potential side effects or prerequisites (like needing admin access) would make it fully complete, but this is not critical for such a straightforward tool.

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

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

The tool has zero parameters, so the baseline is 4 per the rubric. The description adds no parameter information because none exists; the empty schema is sufficient. No further semantic guidance is needed.

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

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

The description uses a specific verb ('Flush') and resource ('WordPress rewrite rules'), and adds the purpose ('fixes permalink issues'). This clearly distinguishes it from all sibling tools, which focus on posts, media, users, etc. The action 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?

The phrase 'fixes permalink issues' tells the agent when to use this tool. There are no explicit alternatives or exclusions, but given that no sibling tool performs a similar function, the usage context is clear. It could benefit from saying when not to use (e.g., if permalinks are not the issue), but this is a minor gap.

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 disclose behavioral traits. It only states that it creates a backup without mentioning where the backup is stored, how long it takes, potential performance impacts, or how to retrieve the backup. This is a significant gap for a mutation-like operation with no safety annotations.

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

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

The description is a single, concise sentence that is front-loaded with the action and scope. Every word earns its place, providing maximum clarity without waste.

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

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

For a backup tool with no annotations and no output schema, the description is too sparse. It doesn't explain the backup destination, return value, or follow-up actions (e.g., using wordpress_list_backups to retrieve it). The description covers the 'what' but not the 'what happens next' or operational impact, making it incomplete for an agent to use effectively.

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

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

The tool has zero parameters, so schema coverage is 100% trivially. Per the rubric, 0 params warrant a baseline of 4. The description adds no parameter information because none is needed.

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

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

The description clearly states the tool's function: 'Create complete site backup (files + database)'. The verb 'Create' and resource 'backup' are explicit, and the parenthetical 'files + database' distinguishes it from sibling tools like wordpress_backup_database and wordpress_backup_files, which are partial backups.

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

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

The description provides clear context: this tool is for a complete backup including both files and database. While it doesn't explicitly name alternatives or exclusions, the phrase 'complete site backup' implies it is used when a full backup is needed, as opposed to partial backup tools. This is sufficient for a 4, but lacks explicit when-not-to-use guidance.

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

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

No annotations are provided, so the description must disclose behavioral traits. It only says 'Generate XML sitemap' without explaining side effects, output, file modifications, or potential performance implications. This is a thin description that lacks transparency beyond the bare action.

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

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

The description is a single, clear sentence with no redundant information. Every word contributes to the core message, making it highly concise and well-structured.

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

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

For a simple 0-parameter tool, the description covers the primary purpose but omits any mention of what the tool returns or what side effects occur. Without an output schema or annotations, this lack of detail leaves some contextual gaps, making it minimally adequate rather than complete.

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

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

The tool has zero parameters, so the baseline is 4. The description does not need to explain parameter semantics, and it does not add anything beyond the schema, which is appropriate for a parameterless tool.

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') and the resource ('XML sitemap for search engines'). It is specific and distinguishes itself from sibling tools, as there is no other sitemap-related tool in the list.

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

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

The description gives no indication of when to use this tool versus alternatives, no prerequisites, and no context on when it should be avoided. It simply states the action without any usage guidance.

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

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

No annotations are provided, so the description carries the full burden. 'Get' implies a read-only operation, but the description does not explicitly state that it has no side effects, nor does it mention any details about the returned plugin data (e.g., version, status). It is minimally transparent but not misleading.

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