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

No annotations are provided, so the description must carry the full behavioral burden. It does not disclose permissions needed, side effects, whether the operation is destructive, or any other behavioral trait beyond the bare implication of creation.

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

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

The description is only four words and front-loaded, but it is under-specified rather than appropriately concise. It omits critical details needed to call a six-parameter mutation tool correctly.

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

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

Given a mutation tool with six parameters, no annotations, and no output schema, the description is wholly inadequate. It provides nothing about required inputs, behavior, or what the tool returns.

Complex tools with many parameters or behaviors need more documentation. 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% for all six parameters, and the description adds no parameter meaning at all. It does not explain the required 'name' field, acceptable values for 'status' or 'stock_status', or price formats.

Input schemas describe structure but not intent. Descriptions should explain 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 verb ('Add') and resource ('WooCommerce product'), so the tool's basic purpose is immediately clear. It does not distinguish itself from siblings like wc_update_product or wc_products_search, which keeps it from a 5.

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

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

There is no guidance on when to use this tool versus alternatives such as wc_update_product, no prerequisites, and no exclusions. The agent must infer usage from the name alone.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only says 'Add a WooCommerce product brand'. It does not cover permissions, duplicate handling, side effects, or the return value, leaving significant gaps 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, front-loaded sentence with no wasted words. However, it is under-specified for the tool's complexity, omitting details that would help an agent call it correctly.

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

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

The tool is a mutation operation with no annotations, no output schema, and three parameters at 0% schema coverage. The description is too sparse to provide the necessary context 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?

Schema description coverage is 0% for 3 parameters, and the description provides no information about the name, slug, or description parameters or which one is required. The description fails to 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 states a specific verb (Add) and resource (WooCommerce product brand), clearly distinguishing it from siblings like product category or tag. However, it does not explicitly differentiate itself from other add tools or clarify the scope beyond the resource name.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 are any prerequisites or exclusions mentioned. The agent must infer usage solely from the tool name and 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?

No annotations are provided, so the description carries the full behavioral burden for a mutation tool. It does not mention permissions/capability requirements, duplicate-slug handling, whether a newly created category ID is returned, or that 'parent' must reference an existing category. For a write operation with zero structured coverage, this is a substantial 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?

A single, front-loaded sentence with no filler — efficient and easy to parse. Its brevity is a virtue structurally, though it comes at the cost of the missing detail noted elsewhere.

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

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

Given a 4-parameter mutation tool with no annotations, no output schema, and 0% schema description coverage, the description is far too thin. An agent lacks the information needed to supply valid slug/parent values or to understand the result of the 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?

Schema description coverage is 0% across 4 parameters. The description adds no meaning for 'slug' (format/uniqueness), 'parent' (integer ID vs. name), or 'description' (usage), nor does it indicate that only 'name' is required. It does nothing to compensate for the undocumented 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+resource pair ('Add a WooCommerce product category') that clearly identifies the operation and the taxonomy being targeted, distinguishing it somewhat from wp_add_category (core WP categories). However, it does not explicitly contrast itself with the near-identical sibling wp_add_category, so an agent must infer the taxonomy difference from the name alone.

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

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

There is no guidance on when to use this versus wp_add_category, wc_update_product_category (for existing categories), or wc_list_product_categories. The description states only what the tool does, leaving all routing decisions to the agent's inference from names.

Agents often have multiple tools that could apply. Explicit usage 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 says 'Add' (a mutation), but does not disclose whether this requires authentication, whether adding a duplicate tag errors or returns the existing one, whether it is idempotent, or what happens to existing tags. For a mutation with zero annotation coverage, this is a significant gap.

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

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

A single, front-loaded sentence with zero waste. It is appropriately sized for what it conveys, though it is arguably under-specified given the tool's complexity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 0% parameter documentation, the description is far too thin. It omits auth/permission requirements, duplicate-handling behavior, slug auto-generation, and return shape – all of which an agent needs to invoke it correctly.

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

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

Schema description coverage is 0%, so the description must compensate, but it adds no parameter detail beyond the tool name. The three parameters (name, slug, description) are self-explanatory by name, which keeps this at a minimum-viable 3 rather than lower – but no format, length, uniqueness, or slug-generation behavior is explained.

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

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

States a specific verb+resource ('Add a WooCommerce product tag'), which is clear enough to act on. However, it does not distinguish from sibling wc_add_product_tag vs wc_update_product_tag or wc_add_tag (the non-product tag tool) – the 'product' qualifier is present but the tool gives no guidance on how it differs from the core wp_add_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 when-to-use, when-not-to-use, or alternative guidance. An agent cannot tell from the description whether to use this vs wc_update_product_tag (if the tag may already exist) or wp_add_tag. The one-line description implies creation but provides no context.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It states only 'Delete' and omits critical context: whether the product is trashed or permanently removed, how the force parameter changes behavior, and whether deletion is reversible or requires elevated permissions.

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

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

The description is a single, front-loaded sentence with no filler. It is appropriately sized for a one-sentence summary, though brevity comes at the cost of necessary behavioral detail.

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

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

For a destructive, two-parameter tool with no annotations and no output schema, the description is under-specified. It does not explain side effects, recovery options, or the effect of force, leaving the agent with insufficient context.

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

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

Schema description coverage is 100%, so the id and force parameters are documented in the schema. The description adds no parameter-level meaning beyond the name, so the baseline of 3 applies.

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

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

States a specific verb and resource: 'Delete a WooCommerce product.' It clearly identifies the operation, though it does not differentiate from sibling delete tools such as wp_delete_post or wc_delete_product_category beyond the resource name.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 no guidance on when to use this tool versus alternatives such as wc_update_product or wp_delete_post. There are no prerequisites, warnings, or exclusion criteria mentioned.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it largely fails to do so. It does not disclose the critical WooCommerce distinction between trashing (default) and permanent deletion (force), whether the operation is reversible, what permissions are required, or what happens to products assigned to the brand.

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

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

It is a single short sentence with no padding, and the verb is front-loaded, so it is not verbose. However, the sentence is so minimal that it barely earns its place, delivering almost no information 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 destructive mutation tool with no annotations, no output schema, and an undocumented force parameter, the description is insufficient. An agent cannot determine whether the call removes a brand permanently or only trashes it, nor what it needs to pass for force.

Complex tools with many parameters or behaviors need more documentation. 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 only 50%: 'id' is documented as 'Brand ID' but 'force' has no description at all. The description does not compensate — it never mentions the force flag or explains what it toggles, leaving the most consequential parameter 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 states a verb and resource ('Delete a WooCommerce product brand'), which is clearer than a bare restatement, but it adds essentially nothing beyond what the tool name wc_delete_product_brand already conveys. It does not differentiate this from sibling brand tools (wc_update_product_brand, wc_list_product_brands) or from the category/tag deletion tools.

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

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

There is no when-to-use guidance, no statement of prerequisites or required capabilities, and no mention of alternatives or related tools. The agent is left to infer everything from the name alone.

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

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

No annotations are provided, so the description must carry the behavioral load. It says 'Delete' but does not disclose permanence, required permissions, effect on products, or what the force parameter does, leaving significant gaps 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 a single, front-loaded sentence with no wasted words. However, it is arguably too terse given the tool has a force parameter and is destructive.

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

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

With no annotations, no output schema, one of two parameters undocumented, and no behavioral detail about deletion, the definition lacks context needed 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?

Schema description coverage is 50%: id is documented as 'Category ID', but force has no description in either the schema or the tool description. The description adds no parameter meaning, so it fails to compensate for the undocumented force 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 states a specific verb 'Delete' and resource 'WooCommerce product category', making the core action clear. However, it does not differentiate from sibling delete tools such as wc_delete_product, wc_delete_product_tag, or wc_delete_product_brand.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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, and no exclusions. The description merely restates the action without context.

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

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

With no annotations provided, the description carries the full behavioral burden, yet it only implies a destructive write. It says nothing about whether deletion is permanent or sent to trash, what the force parameter does to that behavior, whether auth/permissions are required, or what happens to tags still attached to products. For a delete operation with zero annotation coverage this is a significant gap.

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

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

One sentence with no padding and the verb is front-loaded, which is good. But at this length the terseness reads as under-specification rather than disciplined concision, since essential delete semantics are omitted.

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

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

A destructive tool with no annotations, no output schema, and an undocumented 'force' parameter leaves an agent unable to call it correctly or predict consequences. The description should at minimum explain the force/trash distinction and confirm the destructive nature.

Complex tools with many parameters or behaviors need more documentation. 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 only 50%: 'id' is documented as 'Tag ID' in the schema, but 'force' has no description anywhere. For a delete tool, 'force' is the semantically critical parameter (trash vs permanent deletion), and the description does nothing to compensate for the schema's silence.

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

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

States a specific verb (Delete) and resource (WooCommerce product tag), which cleanly separates it from wc_delete_product, wc_delete_product_category, and wc_delete_product_brand. It does not, however, explicitly contrast itself with alternatives such as wc_update_product_tag or wp_delete_tag, so it stops short of the sibling differentiation a 5 requires.

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

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

The description offers no guidance on when to use this tool versus the update or list variants, and no prerequisites (permissions, whether the tag must be unassigned from products first). It is a bare statement of intent 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?

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing: no permissions/auth requirements, no error semantics for a missing order, no mention of the read-only nature beyond the verb 'Get'. For a tool with zero annotation coverage this is a significant gap.

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

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

A single front-loaded sentence with no filler. It is efficient, though brevity here borders on underspecification rather than tight writing.

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

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

For a simple single-parameter getter with no output schema, the description is minimally viable but omits return-shape hints and failure behavior. Acceptable but with clear gaps given no annotations exist to cover them.

Complex tools with many parameters or behaviors need more documentation. 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 schema only labels the field 'id' as an integer. The description's 'by ID' confirms the parameter is an order identifier, adding marginal meaning, but it does not specify format, whether it accepts order number vs internal ID, or valid ranges. A 3 reflects the minimal compensation 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?

States a specific verb+resource ('Get WooCommerce order') and scopes it to ID lookup, which implicitly distinguishes it from the sibling wc_orders_search. It does not name the sibling explicitly, so it falls short of full differentiation.

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

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

No guidance on when to use this vs wc_orders_search or what to do if the ID is unknown/invalid. The 'by ID' phrasing hints at single-record lookup, but usage conditions are left 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?

No annotations are provided, so the description carries the full disclosure burden, yet it says nothing about behavior: whether the call is read-only (only implied by 'Get'), what happens on an invalid or missing ID, or what shape of product data is returned.

Agents need to know what a tool does to the 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 short sentence with the resource and lookup key front-loaded. Nothing is padded or redundant.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 trivial one-parameter getter this is nearly sufficient, but with no annotations and no output schema the description should at minimum note that it is a read operation and what it returns or how it fails, which it does not.

Complex tools with many parameters or behaviors need more documentation. 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 single 'id' property is undocumented in the schema, but 'by ID' does clarify that the parameter is the product identifier rather than, say, a SKU or slug. This is a marginal but real addition over the bare 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?

States a specific verb ('Get') and resource ('WooCommerce product') plus the retrieval key ('by ID'). An agent can distinguish it from wc_products_search (which lists/searches), though the description never names that sibling explicitly.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 'by ID' weakly implies you must already hold a product ID, but there is no explicit guidance on when to use this versus wc_products_search to look up a product, and no prerequisites or exclusions are stated.

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

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

With no annotations at all, the description carries the full behavioral burden, yet it says nothing about pagination behavior, default ordering, return shape, or auth requirements. 'List' implies a non-mutating read, which is the only behavioral signal present, leaving substantial gaps for a tool with two paging parameters.

Agents need to know what a tool does to the 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 short sentence is front-loaded and wastes no words, but it is under-specified rather than genuinely concise. Nothing is redundant; there is simply too little content for a tool with paging parameters.

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

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

For a read-only list tool with two undocumented parameters, no output schema, and no annotations, the definition omits pagination behavior, result ordering, and response shape. An agent can guess the call but cannot predict what it will get back.

Complex tools with many parameters or behaviors need more documentation. 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 neither 'page' nor 'per_page' is documented anywhere. The description adds no meaning about paging semantics, valid ranges, or defaults, so it fails to compensate for the coverage gap; only the trivial fact that the tool returns a listing is conveyed.

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

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

The description pairs a specific verb ('List') with a specific resource ('WooCommerce product brands'), so an agent immediately knows this is a read operation over product brands. It does not explicitly distinguish itself from the sibling write tools (wc_add/update/delete_product_brand), but the name/verb already separates read from write, so 4 rather than 5.

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

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

There is no when-to-use guidance, no mention of alternatives (e.g., wc_list_product_categories/tags or wc_products_search), and no prerequisites or exclusions. Only the verb 'List' weakly implies read-only retrieval, which is not enough to count as contextual 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 behavioral burden. It does not state that this is a safe read-only operation, how results are paginated (despite page/per_page params), what the default ordering is, or whether authentication is required — significant gaps for a list tool with zero annotation coverage.

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

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

A single front-loaded sentence with no filler or redundancy. It is appropriately tight, though the brevity comes at the cost of the guidance the tool needs rather than being a model of efficient completeness.

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

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

With no output schema, no annotations, and undocumented parameters, the description should explain at least the shape of the returned category list and the pagination contract. It provides none of that, leaving the agent under-informed for even a simple list 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?

Schema description coverage is 0% for both parameters. The description says nothing about page or per_page, so the agent gets no meaning beyond the bare parameter names and defaults, and no hint about maximum page size or result limits.

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

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

States a specific verb (List) and resource (WooCommerce product categories), which distinguishes it from the sibling wp_list_categories (blog categories). It stops short of explicitly naming that alternative or its own mutation siblings (wc_add/update/delete_product_category), so differentiation is only implicit.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 statement of when to use this tool versus wp_list_categories, wc_list_product_tags, or wc_list_product_brands, nor any prerequisites or pagination guidance. The agent is left to infer usage entirely 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 the full behavioral burden, yet it says nothing about pagination behavior, default/max page sizes, or the shape of returned tag data. For a paginated list tool this is a meaningful 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?

A single compact sentence with no waste and the resource front-loaded. It is efficient, though the brevity reflects under-specification rather than deliberate crispness.

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

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

A list tool with undocumented pagination parameters and no output schema leaves the agent without return-shape or paging guidance. The description does not fill this gap.

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

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

Schema description coverage is 0% for two parameters (page, per_page), and the description adds no meaning about what they control or their defaults/bounds. With low coverage the description should compensate but does not.

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

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

States a specific verb and resource ('List WooCommerce product tags'), and the 'product' qualifier implicitly separates it from the generic wp_list_tags sibling. It is clear but does not explicitly name or contrast with that sibling.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 indication of when to use this versus wc_products_search or wp_list_tags, nor any prerequisite or context for listing product tags. Usage must be inferred entirely 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 the full behavioral burden, and it discloses almost nothing. It does not state that this is a read-only operation, how pagination behaves, what the default result ordering/size is, or what the response contains. Only the implicit non-destructiveness of "search" provides any signal.

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

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

At four words it is certainly front-loaded and free of padding, but the brevity comes from omission rather than disciplined editing. It is too short for a three-parameter search tool, so it is under-specified rather than well-sized.

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

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

With no annotations, no output schema, 0% parameter coverage, and no usage guidance, an agent lacks nearly everything needed to invoke this tool confidently. The description does nothing to fill the gap left by the structured 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?

All three parameters (page, status, per_page) have 0% schema description coverage, and the description adds no information about any of them. In particular, valid values for status and the interaction between page and per_page are left entirely undocumented, so the description fails to compensate for the coverage 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?

"Search WooCommerce orders" names a verb (search) and a resource (WooCommerce orders), so the function is decipherable. But it is nearly a restatement of the tool name wc_orders_search and draws no boundary against siblings such as wc_get_order (single order retrieval) or wc_products_search. Adequate but minimally informative.

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

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

There is no when-to-use guidance, no mention of alternatives (e.g., wc_get_order for a known ID), and no stated prerequisites or filtering context. An agent must infer everything about selection from the tool name alone.

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

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

With no annotations provided, the description carries the full behavioral burden and discloses almost nothing. It implies a read-only search, but says nothing about return volume, pagination behavior, result ordering, or required permissions.

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

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

A single short sentence with no wasted words and the resource stated up front. It is concise, but the brevity reflects under-specification rather than efficient communication of needed detail.

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

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

For a 3-parameter tool with no annotations, no output schema, and no parameter descriptions, the definition is inadequate. An agent cannot determine what results to expect, how to page through them, or how this differs from sibling search tools.

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

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

Schema description coverage is 0% across all three parameters (page, search, per_page), and the description mentions none of them. 'Search' hints at a query term, but pagination semantics for page/per_page go entirely undocumented in both schema and description.

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

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

The description states a specific verb ('Search') and resource ('WooCommerce products'), which is better than a pure tautology. However, it does not distinguish this tool from its many siblings such as wc_orders_search, wp_posts_search, or wc_get_product, leaving the agent to infer scope from the name alone.

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

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

There is no guidance on when to use this tool versus alternatives like wc_get_product (single lookup) or the other wc_*_search tools. The word 'Search' implies a browsing/lookup use case, but no conditions, prerequisites, or exclusions are stated.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it says nothing. It does not disclose whether this is a partial or full update (i.e. whether omitted fields like name or sale_price are preserved or cleared), whether it requires authentication, or whether the change is reversible.

Agents need to know what a tool does to the 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 single sentence is front-loaded and free of filler, but its brevity stems from under-specification rather than efficient communication. It is appropriately sized for what it attempts, but it attempts very little.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 seven-parameter mutation tool with no annotations, no output schema, and near-zero schema descriptions, the description is wholly inadequate. An agent cannot safely invoke this tool knowing only that it 'updates a product'.

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

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

Seven parameters with only 14% schema description coverage (only 'id'), yet the description adds zero parameter meaning. Fields like status, stock_status, regular_price and sale_price have no documented allowed values, formats, or defaults in either the schema or the description.

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

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

States a specific verb and resource ('Update a WooCommerce product'), which an agent can distinguish from wc_add_product and wc_delete_product by the verb alone. It is clear but adds no detail about scope or which attributes can be changed, so it does not differentiate beyond the operation 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?

The description gives no when-to-use guidance, no prerequisites (e.g. permissions), and never references siblings such as wc_get_product to fetch current values first or wc_add_product for creation. Usage must be inferred entirely from the verb.

Agents often have multiple tools that could apply. Explicit usage 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 behavioral disclosure. 'Update' implies mutation, but the description omits permissions, reversibility, side effects, and what happens to unspecified fields, which is a significant gap for a write 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?

A single front-loaded sentence with no wasted words, so it is structurally efficient. However, it is arguably too terse for a 4-parameter mutation tool, which slightly reduces its appropriateness.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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, 4 parameters, and only 25% schema coverage, the description is far too thin. It lacks field-level guidance, permissions, and behavioral context that an agent needs to call it correctly.

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

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

Schema description coverage is only 25% (only 'id' is described as 'Brand ID'), and the description adds no parameter details. It does not clarify the roles of name, slug, or description, so it 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?

States a specific verb (Update) and resource (WooCommerce product brand), which is clear. However, it does not distinguish this from sibling update tools like wc_update_product_category or wc_update_product_tag, so it falls short of the 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?

Provides no guidance on when to use this tool versus alternatives such as wc_add_product_brand or wc_update_product. There are no prerequisites, exclusions, or contextual cues, leaving the agent to infer usage entirely.

Agents often have multiple tools that could apply. Explicit usage 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 disclosure burden and fails to meet it. It never says whether this is a partial or full replacement update, whether omitted fields are preserved or cleared, what permissions are required, or what the response contains. 'Update' alone is thin 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?

A single grammatical sentence with no filler and no redundancy, so it is not padded. But the brevity is under-specification rather than disciplined conciseness — nothing is front-loaded because there is nothing else to front-load.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 5-parameter mutation tool with no annotations, no output schema, and 20% schema description coverage, the definition leaves major gaps: update semantics, required permissions, and return behavior are all unspecified. The one-line description is not complete enough for reliable invocation.

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

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

Schema description coverage is only 20% (only 'id' is documented), yet the description adds zero parameter meaning. An agent cannot tell from the definition whether 'parent' expects an existing category ID, whether 'slug' must be unique, or whether passing only 'id' plus 'name' is a valid partial update.

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

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

States a specific verb (update) and resource (WooCommerce product category), which cleanly separates it from the add/delete/list siblings in the same family. However, it does nothing to distinguish itself textually from wc_update_product, wc_update_product_tag, or wc_update_product_brand beyond the resource name in the title-like sentence.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 versus wc_update_product, wc_update_category (the WordPress core sibling), or wc_add_product_category. No prerequisites, no mention of whether the category must already exist, and no exclusion conditions are stated.

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

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

No annotations are provided, so the description carries the full disclosure burden, and it says nothing about permissions, whether the update is partial or full, whether omitted fields are cleared, or whether the change is reversible. 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 single sentence is front-loaded, contains no padding, and is easy to scan. However, its brevity reads as under-specification rather than discipline, since essential calling information is absent.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 4-parameter write operation with no annotations and no output schema, the description should at minimum clarify partial-update behavior and field meanings. It supplies none of that, 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 only 25% — just 'id' is documented, while 'name', 'slug' and 'description' have no descriptions anywhere. The tool description adds no parameter meaning (e.g. uniqueness of slug, rename vs. reassign semantics), so it fails to compensate for the coverage 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 phrase 'Update a WooCommerce product tag' gives a specific verb plus resource, and the sibling names (wc_add_product_tag, wc_delete_product_tag, wc_list_product_tags) make the operation unambiguous. It stops short of saying what can be updated or how broadly, so it is clear but not maximally informative.

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

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

There is no when-to-use guidance, no mention of the sibling update tools for categories/brands, and no indication of prerequisites such as needing an existing tag ID. The agent must infer everything 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 the full burden. It establishes only that this is a write operation; it says nothing about auth requirements, duplicate-name/slug handling, whether an existing term is returned or an error raised, or whether parents must pre-exist.

Agents need to know what a tool does to the 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 single sentence is front-loaded and wastes no words, but its brevity reflects under-specification rather than disciplined concision. Fine as a label, too thin as an instruction.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 four undocumented parameters, the description should do substantial work and does almost none. An agent has no way to know the response shape or failure modes.

Complex tools with many parameters or behaviors need more documentation. 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% for four parameters, and the description mentions none of them. Meaning for 'slug', 'parent' (id vs name?), and 'description' is unavailable anywhere, leaving the agent unable to populate them 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?

States a specific verb ('Add') and resource ('WordPress category'), which clearly distinguishes it from wp_add_tag and the wc_add_product_category sibling. It stops short of any explicit sibling differentiation or scope notes, so it lands at clear-but-undifferentiated.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 versus wp_update_category, the WooCommerce category sibling, or tags, nor any prerequisite such as required capability. The agent must infer usage entirely 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 the full behavioral burden, yet it only says 'upload'. It omits whether write permissions are required, supported file types or size limits, whether the file is copied or moved, and whether the call is reversible. Only the bare mutation intent is conveyed.

Agents need to know what a tool does to the 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 short sentence with the action front-loaded and no filler. It is appropriately sized, though the near-total absence of detail is a coverage problem rather than a conciseness virtue.

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

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

For a mutation tool with no annotations and no output schema, the description leaves key gaps: it never indicates that the response likely returns a media ID, nor any prerequisite (permissions, existing file on disk, accepted formats). More context is needed for an agent to call this correctly.

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

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

Schema description coverage is 100%, so title, alt_text and file_path are all documented in the schema, and the description adds no syntax, format, or path-resolution detail beyond it. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

States a specific verb (upload) and resource (media file) with the target system (WordPress), which clearly identifies it as the media-creation counterpart to wp_get_media, wp_media_search and wp_delete_media. It stops short of explicitly naming those siblings or the scope of the 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?

There is no when-to-use guidance: nothing says when to add media versus searching or getting existing media, nor whether the file must already exist on the server. The agent must infer usage from the name alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure, and it delivers almost nothing. It does not say whether the page is created as draft or published by default, what permissions are needed, or what happens on title collision.

Agents need to know what a tool does to the 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 that is fully front-loaded with no wasted words. It is efficient, but its brevity is under-specification rather than disciplined 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?

A mutation tool with no annotations, no output schema, and 0% schema description coverage needs the description to carry a lot, and this one carries none. An agent cannot know default status, permissions, or return shape from the definition.

Complex tools with many parameters or behaviors need more documentation. 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 meaning at all. In particular the status enum (draft/publish) and the required title/content set are left entirely unexplained, and the schema itself documents nothing.

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

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

States a clear verb (Add) and resource (WordPress page), so the basic purpose is legible. However, it never distinguishes itself from the sibling wp_add_post, which is a near-identical operation, leaving the agent to guess whether pages and posts are interchangeable.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 wp_add_post or wp_update_page. With 47 sibling tools and no routing hints, the agent gets no help selecting correctly.

Agents often have multiple tools that could apply. Explicit usage 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 not state whether the post is published or saved as a draft by default, what permissions are required, or how the new post is returned or identified after creation. For a mutation tool with zero annotation coverage, this is a significant gap.

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

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

A single short sentence that is front-loaded with the verb and resource, with no wasted words. It is perhaps too terse to earn a 5, but nothing in it is extraneous.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 a status parameter whose default is unstated, the description omits details an agent needs to invoke it correctly. It does not say which fields are required or what the default publishing behavior is.

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

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

Schema description coverage is 100%, so all four parameters (title, status enum, content, excerpt) are already documented in the schema. The description adds no format, default, or constraint detail beyond that, so the baseline 3 applies.

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

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

States a specific verb (add) and resource (WordPress post), which is enough to separate it from wp_add_page and wp_add_media at the name level. However, the description itself does not call out what distinguishes a post from a page, so the differentiation relies on the tool name rather than the prose.

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

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

The description gives no guidance on when to use this tool versus wp_add_page, wp_posts_search, or wp_update_post. There is no mention of preconditions or exclusions, leaving an agent to infer usage purely 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 the full behavioral burden, and it discloses nothing beyond the operation itself. It does not mention authentication requirements, duplicate-tag handling, slug auto-generation, or what happens to optional fields. For a mutation tool with zero annotation coverage, this is a severe 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 single sentence is concise and front-loaded, with no wasted words. However, it is so terse that it functions more as a restatement of the tool name than as a useful definition; every sentence earns its place only in the minimal sense.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 three parameters with no schema descriptions, no annotations, and no output schema, the description is too sparse to call this tool correctly with confidence. It identifies the operation but omits required parameter meaning, side effects, and response behavior.

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

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

Schema description coverage is 0%, and the description does not mention any parameters. The required 'name' field and optional 'slug' and 'description' fields are left entirely unexplained, so the description does not compensate for the undocumented schema.

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

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

The description states a clear verb and resource: adding a WordPress tag. It is understandable in isolation, though it does not explicitly distinguish itself from close siblings such as wp_add_category or wc_add_product_tag. The 'WordPress' qualifier helps narrow scope, but sibling differentiation is left implicit.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 wp_update_tag or wc_add_product_tag. The description gives only the bare operation, leaving all usage context to inference from the name and sibling list.

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

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

No annotations are provided, so the description carries the full behavioral burden and delivers almost nothing beyond 'this creates something'. It omits whether a password is generated when omitted, what a missing 'role' defaults to, whether a notification email is sent, whether the caller must be authenticated, and whether the operation fails on duplicate usernames.

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

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

It is a single, front-loaded sentence with no wasted words, which is good structure. But for a six-parameter mutation tool the brevity is under-specification rather than genuine conciseness, so it cannot rate highly on this dimension.

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

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

With no annotations, no output schema, six undocumented parameters at 0% schema coverage, and only a five-word description, an agent lacks nearly everything needed to invoke this correctly. The definition is materially incomplete for the tool's complexity.

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

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

Schema description coverage is 0% and the description names none of the six parameters. An agent gets no indication of accepted role values, email format requirements, password handling, or how first_name/last_name relate to the user record. Nothing compensates for the coverage 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 states a specific verb and resource ('Add a new WordPress user'), making the operation immediately clear and distinguishable from siblings like wp_add_post or wp_add_page. It does not, however, differentiate from the adjacent wp_update_user / wp_delete_user lifecycle tools, so it stops short of the top mark.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 wp_update_user or wp_users_search, nor any statement of prerequisites such as required capability or admin-level permissions. The agent must infer an appropriate calling context entirely from the tool name.

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

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

Annotations are absent, so the description must carry full behavioral burden. 'Delete' implies a destructive mutation, but it omits critical details such as whether deletion is permanent, what happens to associated posts, and what permissions are required.

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

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

A single, front-loaded sentence with zero waste. It is appropriately sized for a simple one-parameter tool.

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

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

For a destructive operation with no annotations and no output schema, the description is too sparse. It should mention behavioral details like permanence, side effects, or required capabilities to be complete.

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

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

Schema coverage is 100% with the 'id' parameter fully described as 'Category ID'. The description adds no additional semantic meaning, but baseline 3 is appropriate when the schema handles parameter documentation.

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

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

States a specific verb 'Delete' and resource 'WordPress category', clearly distinguishing it from sibling tools like wp_update_category and wp_add_category.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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, no prerequisites, and no exclusions. The description merely restates the action without context on 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?

No annotations are provided, so the description carries the full behavioral burden and it delivers almost nothing: it does not state that deletion is destructive or irreversible when forced, does not say the default is a soft-delete/trash, and does not mention permission or authentication requirements. For a mutation tool with zero annotation coverage, this is a significant gap.

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

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

A single short sentence with zero filler, and the purpose is front-loaded. It is efficient, though arguably under-specified rather than optimally 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?

This is a destructive operation with no annotations and no output schema, so the description should disclose reversibility, the trash default, and what the response returns. None of that is present, leaving the agent without the context needed to call it 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 100% (both 'id' and 'force' are documented in the schema), so the baseline is 3. The description adds no parameter meaning of its own, but nothing is missing from the schema side.

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

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

Clear verb+resource combination ('Delete a WordPress media item') that identifies the domain and object unambiguously. It does not explicitly differentiate itself from sibling destructive tools (wp_delete_post, wc_delete_product, etc.), but the resource noun makes the target 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?

No guidance on when to use this versus wp_get_media, wp_update_post-adjacent flows, or how it relates to other media tools. Nothing is said about the trash-vs-permanent distinction that the 'force' parameter implies, so the agent must infer the default behavior.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says 'delete' but never discloses whether the page is trashed or permanently removed, whether it is recoverable, what happens to child pages or associated media, or what occurs if the ID does not exist — all critical for an irreversible-looking mutation.

Agents need to know what a tool does to the 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 tight sentence with the action and resource front-loaded and no filler. It is efficient, though it is minimal to the point of under-specification rather than optimized 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?

For a destructive single-target operation with no annotations and no output schema, the description omits the facts an agent most needs: permanence/trash semantics, permission requirements, and error behavior. The safety and side-effect picture is left entirely to inference.

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

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

Schema description coverage is 100% and only one parameter exists, so the schema already documents the integer id as 'Page ID'. The description's 'by ID' adds no format, validity, or lookup guidance beyond that, making 3 the correct 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?

States a specific verb and resource ('Delete a WordPress page') with the identifier scope ('by ID'), which separates it from wp_delete_post and the other delete_* siblings in the family. It does not explicitly name the alternative, but the noun choice is precise enough that an agent can pick the page variant without opening the schema.

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

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

No indication of when this tool is appropriate versus wp_update_page, wp_get_page, or its closest sibling wp_delete_post. There is also no mention of prerequisites such as required capabilities or whether the operation needs confirmation, so selection guidance is effectively 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 for behavioral disclosure. It implies a destructive action via 'Delete' but does not say whether the post is moved to trash or permanently removed, what permissions are required, or whether the operation is reversible.

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

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

The description is a single, front-loaded sentence with no wasted words. It is appropriately sized for a simple one-parameter tool.

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

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

Given the absence of annotations and an output schema, the description should explain key behavioral details for a delete operation, such as whether deletion is permanent or to trash, and any permission requirements. These are missing, leaving the agent without enough 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?

The tool has one parameter and schema description coverage is 100%, so the schema already fully documents 'id'. The phrase 'by ID' adds no meaning beyond the schema, making the baseline of 3 appropriate.

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

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

The description states a specific verb ('Delete') and resource ('WordPress post') with an ID qualifier. It clearly distinguishes this tool from sibling delete operations for pages, media, categories, tags, and users by naming the resource.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 indication of when to use this tool versus alternatives (e.g., trash vs permanent deletion, batch deletion, or restoring). No prerequisites or exclusions are mentioned.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure, and it discloses nothing. It does not say whether the tag is permanently deleted or moved to trash, what happens to posts/media already carrying the tag, whether authentication or elevated capability is required, or whether the operation is reversible.

Agents need to know what a tool does to the 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 single sentence is front-loaded and short, but this is under-specification rather than genuine conciseness. The brevity comes at the cost of omitting any useful information, so the sentence does not earn its place as a complete definition.

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

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

For a destructive mutation tool with no annotations and no output schema, the description should at minimum state the deletion semantics, effects on related content, and required permissions. It provides none of these, leaving the agent without the information needed to invoke it 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?

There is a single parameter with 100% schema description coverage ('Tag ID', required), so the schema already carries the parameter semantics. Per the rubric, a high coverage baseline of 3 is appropriate when the description adds no further parameter 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 simply restates the tool name: 'Delete a WordPress tag' adds no information beyond wp_delete_tag. It does not distinguish the tool from siblings like wp_delete_category, wp_delete_post, or wc_delete_product_tag, which all share the same verb pattern. This is effectively a tautology.

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

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

No guidance on when to use this tool versus alternatives such as wp_update_tag or wc_delete_product_tag. There is no mention of prerequisites (e.g., permissions) or conditions under which deletion is appropriate or should be avoided.

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

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

With no annotations provided, the description carries the full behavioral burden and falls short. It does not disclose that this is an irreversible destructive operation, whether the reassign parameter is required when the user has posts, or what happens to the user's content by default.

Agents need to know what a tool does to the 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 efficient sentence with the action front-loaded and no wasted words. It is appropriately sized, though its brevity comes at the cost of the behavioral detail a destructive tool warrants.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 delete with no annotations and no output schema, the description is too thin. An agent still lacks the default reassignment behavior and any irreversibility or confirmation context needed to call this 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 100%, so both 'id' and 'reassign' are documented in the schema itself. The description adds no meaning beyond it, which makes the baseline 3 appropriate.

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

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

The description states a specific verb and resource ('Delete a WordPress user'), so the agent knows exactly the operation and target. It does not distinguish itself from sibling user tools such as wp_update_user or wp_get_user, but 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?

There is no guidance on when to use this versus alternatives, nor any prerequisite or caution. Notably absent is what happens when a user owns content and whether reassignment is expected, which is the key decision an agent faces before deleting a user.

Agents often have multiple tools that could apply. Explicit usage 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, but the description says nothing about permissions, behavior when the ID doesn't exist, or what media fields are returned — a notable gap for a tool with zero annotation coverage.

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

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

A single tight sentence with no waste and the key constraint (by ID) front-loaded. It is efficient, though it borders on under-specification rather than ideal 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?

For a simple single-parameter getter this is minimally adequate, but with no output schema and no annotations the description could reasonably say more about the returned media object or failure modes.

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

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

Schema coverage is 100% and the single parameter is fully documented as 'Media ID'. The description's 'by ID' merely restates the schema, so the baseline 3 is appropriate.

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

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

States a specific verb (Get) and resource (WordPress media item) with the lookup key (by ID), which implicitly separates it from wp_media_search. It does not explicitly name the sibling alternative, so it falls short of a 5.

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

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

No when-to-use guidance, no mention of wp_media_search as the alternative for non-ID lookups, and no prerequisite or authentication context. The agent must infer usage purely from the tool name.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it says nothing about whether reading a draft/unpublished page requires authentication, what happens when the ID does not exist, or what the response contains. 'Get' implies a read-only operation but that is inference, not disclosure.

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

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

A single short sentence with the verb and resource front-loaded and no wasted words. It is terse but not padded.

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

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

For a one-parameter read tool with no output schema and no annotations, the minimum viable bar is barely met: an agent can guess the call shape from the name and schema, but gets no help on permissions, error cases, or the shape of the returned page.

Complex tools with many parameters or behaviors need more documentation. 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% for the single required id parameter. The phrase 'by ID' hints at the parameter's role but adds no detail on type (integer), validity range, or whether the ID is a page ID versus a slug — the schema itself declares only 'integer' with no description.

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

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

States a specific verb (Get) and resource (WordPress page) keyed by ID. It is distinguishable from wp_get_post by naming 'page', but it does not explicitly contrast itself with siblings like wp_get_post or wp_pages_search.

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

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

There is no when-to-use guidance at all — nothing about when to fetch a single page by ID versus using wp_pages_search, nor any precondition for calling it.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it does almost nothing with it. It does not say the operation is read-only, what happens when the ID does not exist (error vs empty), whether the post is returned including content/meta, or any 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?

A single front-loaded sentence with zero filler. It is efficient, though arguably under-specified rather than optimally 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 one-parameter read tool with no output schema, the definition is minimally sufficient to invoke, but leaves out error behavior and what the returned post includes. A brief note on missing-ID handling and return shape would make it complete.

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

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

Schema description coverage is 100% and there is only one parameter ('id: Post ID'), so the schema already documents everything. The description adds no format hints (e.g., that the ID is the numeric post ID, not a slug), so baseline 3 is appropriate.

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

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

States a specific verb (Get), resource (WordPress post), and lookup key (by ID), so the agent knows exactly what it retrieves. It does not explicitly distinguish itself from the near-identical sibling wp_get_page or from wp_posts_search, so sibling differentiation relies on the name alone.

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

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

No guidance on when to use this versus wp_posts_search (for discovering posts) or wp_get_page (for pages). The agent must infer that a known ID is required and that search is the alternative when the ID is unknown.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Get' implies a read-only operation, but the description says nothing about auth/permission requirements, whether any settings are sensitive, or what the response contains.

Agents need to know what a tool does to the 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 short sentence, front-loaded and free of padding. It is close to a restatement of the name, but it wastes nothing.

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

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

With no output schema and no description of what 'settings' encompasses (general options, reading, discussion, permalinks, etc.), an agent cannot anticipate the return payload. The overlap with wp_get_site_info is also left unresolved.

Complex tools with many parameters or behaviors need more documentation. 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 takes zero parameters, so there is nothing for the description to disambiguate; the baseline for a parameterless tool applies.

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

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

States a clear verb ('Get') and resource ('WordPress site settings'), so an agent knows this is a read of settings. It does not, however, distinguish itself from the sibling wp_get_site_info, which an agent could easily confuse with it.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 call this rather than wp_get_site_info, nor any mention that wp_update_settings is the write counterpart. Usage must be entirely inferred 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 the full behavioral burden. It implies a read-only operation but does not state whether authentication is required, whether the call is safe, or what the response contains. For a tool with zero annotation coverage, this is a significant gap.

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

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

The description is a single front-loaded sentence with no wasted words. It is appropriately sized for the tool's apparent simplicity, though the brevity leaves important context unstated.

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

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

There is no output schema, so the description should explain what 'site information' includes. It also has no annotations to cover the safety profile. For a zero-parameter tool, the description is underspecified about return values and behavior, leaving the agent with too little to call 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 tool takes zero parameters, so there is no parameter semantics to document. Per the rubric, zero parameters sets a baseline of 4, and the empty schema is consistent with the description.

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

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

It states a clear verb and resource, but 'site information' is vague about what data is returned and does not distinguish this from the sibling wp_get_settings. Without naming the type of information, the agent cannot tell exactly what this tool provides versus the settings tool.

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

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

No when-to-use guidance is offered, and there is no mention of alternatives such as wp_get_settings or wp_list_categories. The agent must infer the tool's context entirely from its 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 must carry the full behavioral burden. It only says what it does, not what happens if the ID doesn't exist, whether it requires authentication, what fields are returned, or whether it's a safe read operation. Very sparse for a retrieval tool 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?

Single, short sentence with zero waste. Front-loaded and clear.

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

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

For a simple getter with no output schema and no annotations, the description is too minimal. It doesn't mention authentication requirements, error behavior, or what user data is returned, leaving the agent guessing about invocation prerequisites and 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 coverage is 0% and there is only 1 parameter (id), which is required. The description repeats the parameter name but adds no format, range, or semantics beyond what's already in the schema. Baseline for 1 parameter with high schema coverage would be 3, but here coverage is low; however, the parameter is self-evident (an integer ID), so the lack of extra detail is less critical.

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

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

Clearly states the specific verb (Get) and resource (WordPress user) with the ID-based lookup. Siblings like wp_get_post, wp_get_page, wp_get_media follow the same pattern, so it's distinguishable by resource name, but no extra differentiation is offered.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 versus wp_users_search or other user tools. It implies retrieval by ID but doesn't tell the agent to search if the ID is unknown.

Agents often have multiple tools that could apply. Explicit usage 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 full behavioral burden. It only says 'List all WordPress categories' and does not disclose read-only status, pagination behavior, return format, or any other behavioral trait. While 'List' implies a read operation, this is not made explicit.

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

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

The description is a single, front-loaded sentence with no wasted words. It is appropriately sized for a simple zero-parameter list tool.

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

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

For a zero-parameter read tool, the description is sufficient to know what it does, but it lacks behavioral context such as output format or whether the list is paginated. With no annotations and no output schema, it leaves some gaps that could matter to 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?

The tool has zero parameters, and per the scoring guidelines, a 0-parameter tool receives a baseline of 4. The description adds no parameter information, but 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 states a specific verb ('List') and resource ('WordPress categories'), making the tool's purpose clear. It implicitly distinguishes from WooCommerce product categories by saying 'WordPress categories', but it does not name a sibling tool or explicitly differentiate from other list operations like wp_list_tags or wc_list_product_categories.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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. The description does not mention prerequisites, exclusions, or that it should be preferred over wc_list_product_categories for core WordPress categories. It only states the action without any usage context.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'List' implies a read-only operation, but no permissions, pagination, ordering, or response behavior is disclosed.

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

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

The description is a single short sentence with no filler. It is front-loaded and fully concise for a zero-parameter list tool.

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

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

For a simple list tool with no input parameters, the description states what is returned. However, with no output schema and no annotations, it does not mention pagination, ordering, or authentication context that an agent might need.

Complex tools with many parameters or behaviors need more documentation. 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 fully described. There is no parameter meaning for the description to add, so the baseline of 4 applies.

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

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

The description gives a clear verb and resource: 'List all WordPress tags'. It implicitly separates itself from add/update/delete tag tools and from WooCommerce product tag tools, but it does not explicitly name any sibling or scoping alternative.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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, nor any exclusions or prerequisites. The empty parameter schema means there are no invocation choices to guide either.

Agents often have multiple tools that could apply. Explicit usage 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, and it discloses almost nothing: no note on pagination behavior, result set size, permissions required, or whether the search matches title, caption, or metadata. Only the word 'Search' implies a read-only, non-mutating 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?

A single front-loaded sentence with no filler, so nothing is wasted. However, at this length it reads as under-specification rather than disciplined conciseness, since no actionable detail survives.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 search tool with no annotations and no output schema, the definition still omits essential operating context: what is searched, how results are paged, and what a result looks like. It is not wrong, but it is too thin to call 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?

Schema description coverage is 0%, so the two parameters (page, per_page) are undocumented everywhere. The description adds no meaning about pagination defaults or valid ranges, leaving the agent to guess conventional 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?

States a specific verb ('Search') and resource ('WordPress media items'), which is enough to separate it from wp_posts_search, wp_users_search and the other *_search siblings by resource. It does not, however, distinguish the scope of the search (e.g., filters, fields matched) or contrast it with the single-item wp_get_media.

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

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

No when-to-use guidance and no mention of alternatives such as wp_get_media for retrieving a single item. The agent must infer that this is the list-style counterpart to the get/add/delete media tools purely 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 the full disclosure burden, and it discloses almost nothing: it does not confirm the operation is read-only, does not mention default result limits or pagination, and does not describe the response. For a search endpoint with zero annotation coverage this is a substantial 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?

A single five-word sentence with no filler and the purpose front-loaded. It is efficient, though the brevity contributes to the specification gaps noted elsewhere.

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

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

With no output schema, no annotations, and 0% schema description coverage, the description is the only source of semantics and it supplies almost none. An agent can guess the intent but not the filtering, paging, or return behavior.

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

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

Schema description coverage is 0%, so the schema documents none of the three parameters, and the description adds nothing about 'page', 'search', or 'per_page' (e.g. paging behavior or what 'search' matches against). The parameter names are somewhat self-explanatory, which keeps this above a 1, but the description does not compensate for the coverage 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?

States a specific verb ('Search') and resource ('WordPress pages'), so an agent knows it is a read/search tool rather than a mutation. It does not, however, explicitly distinguish itself from the close sibling wp_posts_search beyond the word 'pages' in the name.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 wp_posts_search or wp_get_page, nor any mention of required context such as site or authentication. The agent must infer all routing from the tool name alone.

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

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

No annotations are provided, so the description carries the full burden. It says 'with pagination' but doesn't describe pagination behavior (defaults, limits, max per_page), result ordering, or what the return array contains. For a search tool with zero annotation coverage, this is thin.

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

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

Single sentence, front-loaded with the primary action and scope. Very efficient, though minimal to the point of 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?

With no annotations, no output schema, and only brief param schema coverage, the description does little to explain what the tool returns or how results are organized. It should do more to compensate for the missing structured context.

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

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

Schema description coverage is 100%, so each parameter is already documented in the schema with descriptions and defaults. The description adds no parameter-level meaning beyond that, which is the baseline 3.

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

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

States a specific verb (search/filter) and resource (WordPress posts), which distinguishes it from wp_get_post and the mutation siblings (wp_add_post, wp_update_post, wp_delete_post). It doesn't explicitly distinguish from wp_pages_search, but the resource name 'posts' vs 'pages' is self-evident.

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

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

No when-to-use guidance, no mention of alternatives, no exclusions. An agent gets no help deciding between this and wp_pages_search or wp_get_post.

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

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

With no annotations, the description carries full behavioral burden. It implies a mutation but does not state permission requirements, reversibility, whether omitted fields remain unchanged, or what happens on invalid input. This is inadequate for an update tool with zero annotation coverage.

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

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

The description is a single, efficient sentence that is front-loaded with the action and resource. It is concise, though it provides too little information to fully 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?

For a 5-parameter mutation tool with no annotations, no output schema, and only 20% schema description coverage, the description is completely insufficient. It omits parameter details, usage context, and behavioral traits, leaving the agent with almost no guidance.

Complex tools with many parameters or behaviors need more documentation. 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 only 20% — only 'id' is documented. The description does not explain the other four parameters (name, slug, parent, description), nor does it clarify that only provided fields are updated. With low coverage, the description should compensate but does not.

Input schemas describe structure but not intent. Descriptions should explain 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 verb and resource ('Update a WordPress category'), which is better than a tautology but adds nothing beyond the tool name. It does not distinguish itself from sibling tools such as wp_delete_category or wp_update_tag, nor does it clarify scope (e.g., updates existing categories only).

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 — it does not say when to use this versus wp_add_category or wp_delete_category, nor does it mention prerequisites like valid category IDs. The agent must infer usage from the name and context alone.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it says nothing about mutation semantics. It omits whether this is a partial update (only supplied fields changed) or a full overwrite, whether authentication/permissions are required, and what happens on an invalid ID.

Agents need to know what a tool does to the 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 short sentence with zero filler, and the operation and key are front-loaded. Nothing could be trimmed without losing 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 mutation tool with no annotations and no output schema, the definition leaves the important behavioral questions unanswered: partial vs. full update, status value semantics (e.g. draft/publish), and return payload. The schema covers parameter names but not update behavior.

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

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

Schema description coverage is 100%, so each parameter (id, title, status, content) is already documented in the schema. The description adds only 'by ID', which merely repeats the required parameter, so the baseline 3 applies.

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

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

States a specific verb and resource ('Update a WordPress page') plus the keying mechanism ('by ID'), which cleanly separates it from the parallel wp_update_post sibling. It is clear, but it does not articulate the page-vs-post distinction explicitly, so an agent must infer it from the name alone.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of the alternatives (wp_update_post for posts, wp_add_page for creation, wp_get_page for reads). The agent gets no routing help beyond the tool name.

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

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

No annotations are provided, so the description carries the full behavioral burden and delivers almost none of it. 'Update' implies mutation but there is no word on required capabilities, whether this is a partial or full-replacement update, what happens to fields not supplied, or what the response contains.

Agents need to know what a tool does to the 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 short sentence with no filler, and the mutation and identifier are front-loaded. It is efficient but so terse that it arguably under-serves a five-parameter mutation tool.

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

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

For a write tool with no annotations, no output schema, and five parameters, the definition omits permission requirements, partial-update semantics, and return shape. The 100% schema coverage covers parameter naming but not the operational context an agent needs.

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

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

Schema description coverage is 100%, so all five parameters (id, title, status, content, excerpt) are already documented in the schema. The description adds only the 'by ID' lookup framing, which is marginal value over 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?

States a specific verb (update) and resource (WordPress post) plus the lookup key (by ID). It is clearly distinguishable from wp_add_post, wp_delete_post, and wp_update_page by resource noun, though it never explicitly names those 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?

No when-to-use guidance, no prerequisites, and no mention of alternatives such as wp_add_post for creation or wp_get_post for reading. The agent must infer the calling context entirely 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 the full behavioral burden and largely fails it. "Update" implies mutation, but there is no mention of required privileges (site settings typically need admin), whether omitted fields are preserved or reset, or whether the change is reversible. The only behavioral signal is the verb itself.

Agents need to know what a tool does to the 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 single sentence is front-loaded and free of filler, which is structurally fine. But its brevity here reflects under-specification rather than economy — the tool needs more content, not less.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 four undocumented, all-optional parameters, no annotations, and no output schema, the definition is too thin. An agent has no way to know which settings are updatable, what values are valid, or what the call requires, so it would be guessing before invoking.

Complex tools with many parameters or behaviors need more documentation. 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% for all four parameters (url, email, title, description), and the description adds nothing about their meaning, format, or effect. The agent cannot tell that these map to site title, admin email, tagline, and site URL, nor which are safe to send.

Input schemas describe structure but not intent. Descriptions should explain 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 verb and resource ("Update WordPress site settings"), so the basic action is unambiguous. However, it never says which settings can be changed, and it does not distinguish itself from the sibling wp_get_settings (read counterpart) or clarify scope versus wp_update_user/wp_update_page. The name plus a generic sentence leaves the agent inferring the rest.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 wp_get_settings or the other wp_update_* siblings, and no prerequisites are stated. The agent must guess that this is the only route for site-wide settings.

Agents often have multiple tools that could apply. Explicit usage 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. The word 'Update' implies a mutation but says nothing about required permissions, whether updates are partial or full-replace, whether unspecified fields are preserved, or reversibility. Only minimal mutation context is conveyed.

Agents need to know what a tool does to the 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. However, its brevity is under-specification rather than genuine economy, and it fails to front-load any useful detail.

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

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

For a 4-parameter mutation tool with no annotations, no output schema, and only 25% schema coverage, the description is far too thin. It omits parameter roles, mutation semantics, and sibling differentiation, leaving the agent with insufficient information to call it correctly.

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

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

Schema description coverage is only 25% (only 'id' has a description, and even that is trivially 'Tag ID'). The description adds no parameter meaning at all: it does not clarify that 'id' is required, nor what 'name', 'slug', and 'description' do or how they interact with tag identity. With low schema coverage, the description should compensate but does not.

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

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

States a clear verb (update) and resource (WordPress tag), so the purpose is understandable. However, the description is a bare restatement of the name/title with no scope details (what fields, what WordPress vs WooCommerce tag context) that would distinguish it from sibling tools like wp_add_tag, wp_delete_tag, or wc_update_product_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 on when to use this tool versus alternatives. The description offers no context on prerequisites, no distinction between this and wc_update_product_tag or wp_add_tag, and no indication of when-not-to-use. An agent is left to infer everything from the name alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It doesn't state whether authentication is required, whether updates are partial or full, what happens to unmentioned fields, or any other operational characteristics. A mutation tool with zero annotation coverage needs more 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?

Extremely terse at four words, which is concise but under-specified for a six-parameter mutation tool. It's front-loaded with the core action, but the brevity leaves critical information missing.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 mutation tool with six parameters, one required, no annotations, no output schema, and very low schema description coverage. The description fails to provide necessary context about permissions, partial update behavior, or parameter semantics, making it inadequate for an agent to use safely and 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 only 17%, with just the 'id' parameter described as 'User ID'. The remaining five parameters (role, email, username, last_name, first_name) have no descriptions in either the schema or the tool description, leaving their semantics and constraints undocumented. The description does not compensate for this 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?

States a specific verb (update) and resource (WordPress user). Sibling tools like wp_update_post and wp_update_page make the CRUD pattern predictable, though the description doesn't explicitly distinguish itself from other update tools, which is acceptable given the clear naming convention.

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

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

No guidance on when to use this tool versus alternatives like wp_add_user or wp_delete_user. The description merely restates the operation without context about prerequisites, permissions, or when to prefer this over other user 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not state whether this is read-only, paginated, what permissions are required, or what the response contains, leaving significant gaps for a search 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 efficient and wastes no words. It is concise, though its brevity comes at the cost of substantive detail.

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

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

For a search tool with two undocumented parameters, no annotations, and no output schema, the description is too sparse. It fails to explain search behavior, pagination, or return format, leaving an agent without enough information 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%, so the description must compensate but does not. The two parameters (page, per_page) are undocumented in both schema and description; however, the defaults imply pagination, giving some inference value, hence a baseline of 3.

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

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

States a clear verb (Search) and resource (WordPress users), which is adequate to identify the operation. However, it does not distinguish this from sibling search tools like wp_posts_search or wc_products_search beyond the resource name, and offers no detail about what 'search' entails or returns.

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

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

No guidance on when to use this tool versus alternatives such as wp_get_user or any other retrieval tool. The description merely names the action without context about scenarios, filters, or exclusions.

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