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

With no annotations, the description carries the full behavioral burden and succeeds: it discloses robots.txt respect, Markdown conversion, pagination/truncation behavior with start_index, and the raw:true option for HTML. This goes far beyond what the schema or annotations convey.

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

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

Every sentence contributes meaningful information: core behavior, use case, robots.txt, pagination, and raw output. The description is front-loaded with the primary purpose and uses straightforward, efficient language without redundancy.

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

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

Given no output schema and no annotations, the description covers the return format, pagination mechanism, raw option, and a practical use case. It is not fully exhaustive since error handling and the exact meaning of max_length/timeout_ms are omitted, but it is sufficiently complete for correct selection and basic invocation.

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

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

Schema description coverage is 0%, so the description must explain parameters. It explicitly covers raw and start_index, and url is inherently clear. However, max_length and timeout_ms are not described in the text, leaving some parameter semantics to be inferred from names and schema constraints alone.

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

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

The description opens with a specific verb and resource: 'Fetch any web page by URL' and states exactly what is returned ('content converted to Markdown, plus title and meta description'). It clearly differentiates itself from the WordPress-specific sibling tools by noting it is 'not limited to the configured WordPress site'.

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

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

The description gives clear usage context: 'Useful for pulling content from another page to turn into a WordPress post/page via wp_create_post/wp_create_page.' It does not explicitly contrast with wp_request, but the tool's purpose as external page fetcher is evident enough to guide an agent.

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

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

The description discloses the core side effect (creates a page) and the authentication prerequisite (WP_USERNAME/WP_APP_PASSWORD). However, with no annotations and no output schema, it does not explain default status behavior, whether the page is immediately visible, what happens if credentials are missing, or what the caller receives in response. These are meaningful gaps, though the description is not misleading.

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

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

The description is two short sentences, front-loads the action and resource, and adds the critical credential requirement with no filler. Every sentence contributes useful information.

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

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

For a tool with no annotations, no output schema, and four parameters, the description is underspecified. It omits parameter semantics, response shape, and important defaults such as the resulting page status. The auth note helps, but the description alone is not enough for a caller to invok it correctly in most real contexts.

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

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

Schema description coverage is 0%, so the description needs to compensate by explaining the parameters. It does not mention title, parent, status, or content at all; it only describes the overall operation and auth requirements. The agent receives no additional meaning beyond raw types and an enum.

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

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

The description states a specific action and resource: 'Create a new WordPress page.' This clearly distinguishes it from siblings like wp_create_post by targeting the WordPress 'page' content type rather than a post.

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

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

The use case is clear: the agent should call this when creating a WordPress page. It does not explicitly exclude alternatives such as wp_create_post or wp_update_page, but the action and resource are stated directly, providing clear context without explicit exclusions.

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

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

With no annotations, the description must carry behavioral disclosure. It does reveal an important prerequisite: WP_USERNAME/WP_APP_PASSWORD must be configured. This is useful operational context. However, it does not describe side effects (e.g., publishing, post status behavior), permissions, or response behavior, leaving notable gaps.

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

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

The description is two short sentences with no filler or redundancy. It front-loads the core action and then gives the credential requirement. Every word earns its place.

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

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

For a mutating create tool with no annotations and no output schema, the description is too thin. It omits parameter guidance, usage boundaries, expected return value, and behavioral consequences such as whether the post is published immediately. The auth requirement is helpful but not sufficient for an agent to invoke the tool confidently.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It does not mention title, status, content, required fields, or enum meanings. The schema provides only names/types, and the description adds no parameter-level meaning whatsoever.

Input schemas describe structure but not intent. Descriptions should explain 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: 'Create a new WordPress post.' It is easy to understand what the tool does, and 'create' distinguishes it from the update/delete/get/list siblings. However, it does not explicitly differentiate from wp_create_page or mention the sibling set.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 about when to use this tool versus alternatives. It does not say to use this for new posts only, nor does it point to wp_update_post for edits or wp_create_page for pages. The context for choosing it over siblings is absent.

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

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

With no annotations, the description must carry the full behavioral disclosure burden. It only states the destructive action and the credential prerequisite; it does not say whether deletion is permanent or moves to trash, what the force parameter changes, or what side effects may occur. The verb 'Delete' merely restates the tool name, leaving only the auth note as incremental behavior.

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

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

The description is exactly two sentences and both are necessary: the first states the action, the second states the setup requirement. It is front-loaded with the core purpose and contains no filler, making it a model of concise structure.

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

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

For a destructive tool with no annotations and no output schema, this description is too sparse. It omits parameter semantics, force behavior, permanence, and side effects. While the tool is simple on the surface, the missing nuance around deletion behavior makes the context incomplete for safe invocation.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented parameters. It does not explain what id refers to or what force does, even though force is a boolean whose behavior is ambiguous. An agent must guess whether force controls permanent deletion, bypassing trash, or ignoring errors.

Input schemas describe structure but not intent. Descriptions should explain 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 precise verb and resource: 'Delete a WordPress page.' This clearly distinguishes it from sibling tools like wp_delete_post (which targets posts) and wp_update_page (which updates rather than deletes). The credential requirement is additional context, not a distraction.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 prefer this tool over alternatives, when not to use it, or how it relates to wp_delete_post or force behavior. The required-credentials note is a prerequisite, not a usage criterion, so an agent gets little routing help.

Agents often have multiple tools that could apply. Explicit usage 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 mentions that credentials are required, but it does not disclose whether the deletion is permanent, whether it moves to trash, what the 'force' parameter does, or what side effects might occur. For a destructive tool this is a significant transparency gap.

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

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

The description is short and front-loaded, with the core operation stated first and the credential prerequisite in a second sentence. Both sentences are relevant, though the description could be expanded without becoming overly verbose.

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

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

Given that this is a destructive operation with no annotations and no output schema, the description is incomplete. It does not explain the behavior of 'force', whether the action is reversible, what the response looks like, or how this compares to deleting a page or updating a post's status.

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

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

Schema description coverage is 0%, and the description adds no meaning for the 'id' or 'force' parameters. An agent cannot determine what 'force' does or why 'id' is required beyond the raw type information in the schema.

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

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

The description uses a specific verb ('Delete') and a specific resource ('a WordPress post'), clearly distinguishing it from sibling tools like wp_get_post, wp_update_post, and wp_create_post. It also differentiates from wp_delete_page via the 'post' target.

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

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

The description implies the tool should be used when a WordPress post needs deletion, but it does not explicitly discuss when to prefer this over related tools such as wp_update_post or wp_delete_page. It also does not mention alternatives or exclusion conditions.

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

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

With no annotations, the description carries the full burden, and 'Get' clearly signals a read-only retrieval rather than a mutation. It does not disclose behavior such as what happens when the ID does not exist, authentication requirements, or the response shape, but for a simple getter the basic behavior is reasonably transparent.

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

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

The description is a single, front-loaded sentence with no filler or redundant phrasing. Every word earns its place, and it is appropriately sized for a tool with one parameter.

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

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

The tool is simple: one required parameter, no output schema, and no annotations. The description tells the agent what the tool does and which parameter matters, which is sufficient for basic invocation. However, it does not mention return contents, error behavior, or any prerequisites, leaving a few gaps for a fully self-contained 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?

The input schema only defines 'id' as an integer with no description, and schema description coverage is 0%. The description adds minimal meaning by clarifying the parameter is the page ID, but it does not explain that this is the WordPress page identifier or how it relates to the returned resource beyond the obvious reading.

Input schemas describe structure but not intent. Descriptions should explain 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 ('Get'), a specific resource ('WordPress page'), and the access pattern ('by ID'). It clearly distinguishes from sibling tools like wp_list_pages (listing) and wp_get_post (a different content 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 phrase 'single ... by ID' implies when to use this tool: when the agent needs exactly one page and already has its ID. However, it does not explicitly mention alternatives or exclusion criteria, such as using wp_list_pages for multiple pages or wp_get_post for posts.

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

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

There are no annotations, so the description carries the full burden. 'Get' signals a read-like operation, but the description does not clarify return behavior, whether the post is returned in a particular status, error cases, or whether this is safe and idempotent. It adds little beyond the tool's name.

Agents need to know what a tool does to the 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, direct sentence. Every word is meaningful, and there is no filler or redundancy.

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

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

For a one-parameter getter with no output schema, the description is minimally usable: an agent knows to supply a post ID. But with no annotations and no output schema, the lack of return shape and behavioral detail leaves meaningful gaps.

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

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

The schema documents id as a required integer with bounds but provides no description. The description supplies the key semantic: the id identifies the WordPress post to retrieve. This is helpful but minimal, and it does not add other parameter details.

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

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

The description names a specific verb ('Get'), a specific resource ('a single WordPress post'), and a precise selector ('by ID'). This clearly distinguishes it from siblings like wp_list_posts, wp_get_page, and the post mutation tools.

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

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

The wording implies when to use the tool: when you know a specific post ID and need one post. However, it gives no explicit guidance about when not to use it or which sibling to prefer, so the routing is left implicit.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only restates the operation implied by the name ('List') and adds no detail about pagination, ordering, default limits, response shape, or taxonomy-specific behavior. This is minimally transparent.

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

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

The description is a single, direct sentence with no filler and the core operation is front-loaded. It is concise and easy to parse, though the brevity sacrifices useful behavioral context.

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

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

The tool is simple and the schema gives the single optional parameter a type and constraints, which helps a bit. However, there is no output schema and the description does not describe the response format, pagination, or category-specific details. It is minimally viable but leaves notable gaps.

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

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

Schema description coverage is 0%, and the description does not mention the 'per_page' parameter at all. The agent cannot learn from the description what per_page does, what the default is, or how it affects results. The description completely fails to compensate for the schema's missing parameter documentation.

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

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

The description states a specific verb and resource: 'List WordPress categories.' This is unambiguous and makes the tool's basic function clear. It does not explicitly distinguish itself from siblings like wp_list_posts or wp_list_tags, but the resource name is specific enough.

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

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

The description provides no guidance on when to use this tool versus alternatives such as wp_list_tags or wp_list_posts. There is no mention of when it should or should not be used, so 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?

With no annotations provided, the description carries the full behavioral burden. The verb 'List' conveys that this is a read-only retrieval operation, which is useful. However, it does not disclose return format, pagination defaults, or any media-specific behavior, leaving notable gaps for a tool with no 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 one short, front-loaded sentence with no filler. It states the action and resource immediately, making it appropriately concise for a simple 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?

The tool is simple: one optional parameter, no output schema, and no annotations. The description is minimally sufficient to make a basic call, but it omits return value shape, default page size, and whether any permissions or media types are relevant. It is adequate but not complete.

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

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

The input schema has one parameter, per_page, with 0% schema description coverage, so the description must compensate by explaining it. The description says nothing about per_page, pagination, or how the parameter affects results. The parameter name and min/max constraints give some clue, but the description adds no semantic value.

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

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

The description states a specific verb 'List' against a clear resource, 'WordPress media library items', which immediately distinguishes it from sibling tools like wp_list_posts, wp_list_pages, and wp_list_users. The purpose is unambiguous and directly tied to the tool 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?

The description implies usage whenever media library items are needed, and the resource name differentiates it from other list tools. However, it does not explicitly state when to choose this over alternatives or mention any exclusions, so guidance is only implicit.

Agents often have multiple tools that could apply. Explicit usage 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 implicitly signals a read-only listing operation but does not describe output format, pagination defaults, rate limits, authentication requirements, or any other behavioral traits.

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

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

The description is extremely concise and front-loaded. Every word contributes meaning, and there is no redundant or filler content.

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

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

Given the absence of annotations, output schema, and parameter descriptions, this description is thin. It identifies the tool's core purpose but leaves the agent without enough context about expected results, pagination behavior, or how search interacts with other parameters.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'search and pagination', which loosely maps to the search, page, and per_page parameters, but it does not explain their semantics, defaults, or constraints beyond what the schema already shows.

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

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

The description clearly states the action ('List') and the resource ('WordPress pages'), and this differentiates it from sibling tools like wp_list_posts and wp_get_page without ambiguity.

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

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

The phrase 'Supports search and pagination' implies when the tool is useful, but it does not explicitly distinguish when to use this tool versus alternatives such as wp_get_page for a single page. No exclusions or alternatives are mentioned.

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

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

With no annotations, the description carries the transparency burden. 'List' clearly marks this as a read-only operation, and the second sentence adds that search and pagination are supported. It does not disclose the default status filter or the shape of results, but for a simple list operation the core behavior is stated unambiguously.

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

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

Two short sentences with the action first and no redundant elaboration. Every word contributes; the search/pagination note is the only extra detail and it is useful.

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

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

For a simple 4-parameter list tool, the description gives the essential selection criteria and capability. There is no output schema, so return-shape details are absent, and the default behavior of `status` is unspecified, making it adequate but not complete.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'search' and 'pagination,' which maps to `search`, `page`, and `per_page`, but it does not explain `status` semantics or the defaults of the pagination parameters. The enum on `status` helps, but the description leaves part of the parameter surface unexplained.

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

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

The description states a specific action and resource: 'List WordPress posts.' This clearly identifies the tool as a listing operation and distinguishes it from wp_get_post (single post retrieval) and wp_list_pages (pages) by resource type. It does not explicitly name alternatives or exclusions, so it falls just short of a perfect purpose statement.

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

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

'Supports search and pagination' implies when this tool is suitable: when the task needs a filtered, pageinated collection of posts rather than a single post. However, the description never says to use wp_get_post for a single post or wp_list_pages for pages, so the guidance remains implied rather than explicit.

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

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

No annotations are provided, so the description should carry the behavioral disclosure burden. It only says 'List', which implies a read operation, but it does not state whether the call is read-only, how results are returned, or how pagination behaves. For a tool with no annotation safety profile, this is a significant gap.

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

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

The description is extremely concise and front-loaded with the action, and it contains no redundant text. However, it is under-specified rather than deliberately structured, so it only reaches the minimum viable level for 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?

Given no annotations and no output schema, the description should provide enough operational context for an agent to call the tool correctly. It omits response shape, pagination behavior, and any indication of authorization or side effects. The low complexity of the tool prevents a score of 1, but the 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?

The input schema has one parameter (per_page) with 0% description coverage. The tool description does not mention per_page or explain how pagination works, so it fails to compensate for the low schema coverage. The parameter name and constraints are present, but the description adds no semantic value.

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

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

The description states a clear verb and resource: 'List WordPress tags.' This tells an agent what the tool does and separates it from the post, page, media, and category list tools. However, it is essentially a restatement of the tool name and provides no scope or filtering detail, so it stops short of a top score.

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

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

There is no guidance about when to choose wp_list_tags instead of a sibling like wp_list_categories or wp_list_posts. The description does not mention scenarios, exclusions, or alternatives, so an agent is left to infer usage solely from the resource 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?

There are no annotations, so the description carries the full behavioral burden. It does disclose that WP_USERNAME/WP_APP_PASSWORD is required for full details, which is useful. However, it does not clarify what happens without credentials, whether the operation is explicitly read-only, or any pagination or rate-limit behavior.

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

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

The description is extremely concise: two short sentences with no filler. The core purpose is front-loaded, and the authentication note is a valuable second sentence that earns its place.

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

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

For a simple list operation with one optional parameter, this description is minimally adequate. It gives the purpose and mentions an auth requirement, but it is vague about what 'full details' means, how credentials are supplied, and what the response looks like. Given the absence of annotations and an output schema, more context would be helpful.

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

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

The input schema has zero description coverage for the only parameter, per_page, and the tool description does not mention it either. The parameter name and min/max constraints are somewhat self-explanatory, but the description adds no meaning about pagination or how the parameter affects results.

Input schemas describe structure but not intent. Descriptions should explain 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 the core action clearly: 'List WordPress users.' This is a specific verb and resource that distinguishes it from sibling tools like wp_list_posts or wp_list_pages. However, it does not add any scope or filtering details to further differentiate it from other list 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?

No guidance is given about when to use this tool versus alternatives such as wp_list_posts, wp_list_categories, or wp_request. The only conditional information is the authentication requirement, which is a prerequisite rather than a usage guideline.

Agents often have multiple tools that could apply. Explicit usage 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 explains the URL-relative path rule. It does not mention that the tool can perform mutating requests, how the body is transmitted, what the response format is, or what error behavior an agent should expect from a raw WordPress REST API passthrough.

Agents need to know what a tool does to the 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 a concrete example and no filler. It focuses on the non-obvious routing constraint that an agent could not infer from the parameter names alone.

Shorter descriptions cost fewer tokens and are easier for agents to parse. 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 an unannotated generic HTTP wrapper with three parameters and no output schema, the description omits critical invocation context: default method behavior, how body is used, and what response/error shape to expect. The path rule is essential but not sufficient for safely choosing and calling arbitrary GET, POST, PUT, or DELETE endpoints.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It does add important meaning for path (leading slash and /wp-json relativity), but method and body are left entirely unexplained beyond the schema's bare enum and object type.

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

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

The description clearly identifies wp_request as an escape hatch for WP REST API routes not covered by dedicated sibling tools. The 'any other' phrasing plus the example distinguishes it from the specialized wp_get_post, wp_create_post, and related tools without requiring 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?

'Escape hatch for any other WP REST API route' gives a clear fallback context: use this when no specialized sibling tool matches the endpoint. It does not explicitly state 'use dedicated tools when available' or name exclusions, so it is strong but not fully explicit.

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

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

With no annotations provided, the description must carry the behavioral disclosure burden. It conveys read-only intent through 'Get basic info' and lists the returned data, but it does not explicitly state that no changes are made or what a connection failure looks like. Still, for such a simple informational tool, the implied behavior is reasonably clear.

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

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

Two short sentences, no filler, and the main purpose is front-loaded. Every word earns its place.

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

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

For a no-parameter, no-output-schema tool, the description is complete. It states what the tool does, what data it returns, and why an agent would call it. No additional context is needed for correct invocation.

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

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

The tool has zero parameters, so the baseline is 4. The description adds value by explaining what information is returned, which is useful since the tool takes no input.

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

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

The description clearly states the verb 'Get' and the resource 'basic info about the connected WordPress site,' and lists specific fields (name, url, active namespaces). It is distinct from the sibling tools, which all target posts, pages, media, users, or raw requests.

Agents choose between tools based on descriptions. A clear purpose with a specific verb 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 explicitly says 'Use this to verify the connection,' giving a clear when-to-use context. It does not mention when not to use it, but for a zero-parameter site-info tool this guidance is sufficient and no alternative is really competing.

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

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

With no annotations, the description must disclose behavioral context. It does disclose the authentication prerequisite (WP_USERNAME/WP_APP_PASSWORD), but it remains silent about side effects, error behavior, and what fields are updated or returned, so transparency is incomplete.

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

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

Two concise sentences with no filler; the purpose is front-loaded and the credential requirement is a separate necessary note. Every sentence earns its place.

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

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

The tool has no annotations, no output schema, and four parameters, yet the description only covers purpose and one prerequisite. Given the large sibling set and sparse schema, an agent lacks enough context to select and invoke this tool confidently without additional inference.

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

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

Schema description coverage is 0% and the description adds no meaning for id, title, status, or content. The schema's names and enum provide some structure, but the description does not compensate for the low coverage, so an agent gets no parameter semantics beyond raw property names.

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

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

States a clear verb ('update') and resource ('existing WordPress page'), so an agent can tell this is a mutation targeting pages rather than posts or media. However it doesn't explicitly contrast with sibling tools like wp_create_page or wp_update_post, so it earns 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?

No when-to-use or alternatives are given; the word 'existing' weakly implies it is for updating already-created pages rather than creating new ones. The credential requirement is a prerequisite but not guidance for choosing among wp_create_page, wp_delete_page, or wp_update_post.

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

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

With no annotations, the description carries the behavioral disclosure burden. It discloses the authentication requirement (WP_USERNAME/WP_APP_PASSWORD) and implies a mutation, but it does not explain partial-update semantics, error behavior, or consequences of changing fields.

Agents need to know what a tool does to the 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 two sentences with no filler. The primary purpose is front-loaded, and the credential requirement is a necessary and concise addition.

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

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

For a mutation tool with no annotations and no output schema, the description is too sparse. It fails to explain how partial updates work, what status values are valid, what errors may occur, or what the response contains.

Complex tools with many parameters or behaviors need more documentation. 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 gives no information about the id, title, status, or content parameters. The description does not compensate for the schema's lack of parameter documentation.

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

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

The description states a specific verb and resource: 'Update an existing WordPress post.' It clearly distinguishes this from siblings like wp_create_post, wp_get_post, and wp_delete_post by emphasizing 'existing' and 'Update.'

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

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

The usage is implied but not explicit: an agent can infer that this tool is for modifying an already-created WordPress post, but the description does not explicitly mention when to choose it over wp_create_post or other alternatives.

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