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 mention authentication requirements, whether created comments are held for moderation (pending vs approved), whether anonymous comments require author_name/author_email, or whether the call is idempotent. 'Create' implies mutation but nothing about side effects 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?

A single front-loaded sentence with zero filler — efficient and easy to parse. It is arguably too terse rather than too long, but there is no structural waste.

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

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

An output schema exists and schema coverage is complete, so return values and parameter formats don't need to be restated. However, for a write tool with no annotations, the description omits moderation/auth behavior that an agent would want before invoking it.

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 are documented in the schema itself (including `parent` for replies and the anonymous-comment fields). The description adds no parameter-level meaning beyond that, which lands at 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?

Specific verb (Create) plus resource (comment) plus target (WordPress post) — an agent can tell it apart from wordpress_update_comment or wordpress_get_comment from the name alone. It does not, however, explicitly differentiate itself from the other comment-mutating siblings, so it stops short of a 5.

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

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

No when-to-use guidance, no prerequisites, and no reference to alternatives such as wordpress_update_comment or the reply mechanism via the `parent` parameter. The agent must infer 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?

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing: no authentication/permission requirements, no note that publishing is possible via the status field, no indication of irreversibility, and no hint of what is returned. For a 10-parameter 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?

One short, front-loaded sentence with no waste, but it is under-specified rather than genuinely concise. It is appropriately sized for what it says, yet it says almost 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?

An output schema exists so return values need not be explained, but for a 10-parameter creation tool with zero annotations the description leaves permissions, draft-vs-publish implications, and side effects entirely undocumented. The structured fields cannot fully compensate for that omission.

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 every parameter (title, content, status default draft, parent, template, featured_media, etc.) is documented in the schema itself. The description adds no parameter meaning beyond the schema, 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?

The description states a specific verb and resource ('Create a new WordPress page'), which clearly separates it from wordpress_create_post and wordpress_create_comment. It does not, however, say anything to distinguish it from siblings beyond the noun itself, so it stops short of a 5.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as wordpress_update_page or wordpress_create_post. The agent must infer everything about context 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 behavioral burden, and it discloses almost nothing. It does not state that the post defaults to draft status, that scheduling is possible via date, whether the call requires authentication, or that it performs a write/mutation. Only the schema hints at the draft 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?

The single sentence is front-loaded and free of filler, but it is terse to the point of under-specification rather than efficiently concise. Nothing in the sentence is wasted, yet more could have earned 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?

This is a 10-parameter mutation tool with no annotations and no usage guidance; an output schema exists so return values need no explanation. However, the description says nothing about the draft default, publishing behavior, permissions, or error conditions, leaving the definition inadequate 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 100% and each of the 10 parameters has a meaningful, self-contained description (status enum values, ISO 8601 date format, tag/category ID lists). The description adds no parameter information beyond this, 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+resource ('Create a new WordPress post'), which cleanly separates it from wordpress_update_post, wordpress_get_post, and wordpress_create_page. It stops short of explicitly contrasting with the sibling create_page tool, so it is clear but not maximally differentiating.

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 wordpress_update_post (editing an existing post) or wordpress_create_page. Nothing is said about prerequisites such as authentication or required capability, so an 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?

With no annotations, the description carries the full burden of behavioral disclosure, yet it only states the action. It omits permissions required, whether the operation is reversible in practice, and any side effects on associated data. The schema's force description covers permanent vs trash, but the description adds no safety context.

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

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

One short sentence, front-loaded with the action and resource, with no redundant or vague wording. It is appropriately sized for a simple delete 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?

An output schema exists and parameter coverage is complete, so return values and inputs are handled elsewhere. The description nonetheless leaves gaps in usage routing and safety context that matter for a destructive operation with no annotations. It is minimally adequate but not fully complete.

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

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

Schema description coverage is 100%, so both comment_id and force are fully documented. The description's 'delete or trash' phrasing loosely maps to the force parameter but adds no format or constraint details beyond the schema, matching the baseline of 3 when schema does the heavy lifting.

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

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

The description names a specific verb (delete/trash) and resource (WordPress comment), making the operation immediately clear. However, it does not explicitly differentiate itself from related siblings such as wordpress_delete_post or wordpress_moderate_comment, so it falls 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?

No guidance on when to choose deletion versus trashing beyond the schema flag, nor when to use this instead of wordpress_moderate_comment. The agent receives no context about prerequisites or alternative tools.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing: no statement that deletion is permanent/irreversible, no permission or auth requirements, no side effects. Only the word 'Delete' hints at destructiveness.

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

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

A single front-loaded sentence with no filler or repetition. It is efficient, though its brevity reflects 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?

The tool is destructive with no annotations and no output-schema relief needed, yet the description says nothing about permanence, permissions, or failure modes. The one genuinely important constraint (media cannot be trashed) is left entirely to the schema, so the description is not complete for a destructive operation.

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

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

Schema description coverage is 100% and both parameters are well documented in the schema itself, including the non-obvious 'force must be true' rule. The description adds no meaning beyond the schema, 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 WordPress media item), which is unambiguous and clearly distinct from the delete_post/delete_page/delete_comment siblings by resource name alone. It does not, however, explicitly contrast itself with those siblings or with wordpress_update_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?

There is no guidance on when to use this tool versus alternatives, no prerequisites, and no mention of the irreversible nature of deletion. The critical constraint that media cannot be trashed (force must be true) exists only in the schema, not the 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 destructive operation. It hints at two modes ('delete or trash') but says nothing about irreversibility, required capabilities/permissions, or side effects on revisions and child pages — all of which matter for a permanent delete.

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

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

A single short sentence with no wasted words and the action front-loaded. It is arguably too terse for a destructive tool, but 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?

An output schema exists, so return values need not be explained, but for a destructive tool with zero annotation coverage the description omits critical context: permanence warnings, permission requirements, and what happens to associated data. It is not complete enough for an agent 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 page_id and the force flag (with its default and delete-vs-trash semantics) are fully documented in the schema. The description adds no parameter meaning 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 pair (delete or trash) and resource (WordPress page), which is clear on its own. It does not explicitly distinguish itself from the sibling wordpress_delete_post, though the resource noun does that implicitly.

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 wordpress_delete_post or update_page, and no prerequisites stated. The trash-versus-permanent choice is left entirely to the schema's force parameter.

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. 'Delete or trash' hints that the operation is destructive, but it never states that force=true is irreversible, that trashed posts may be recoverable, what happens to comments/revisions, or 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 short sentence with no wasted words and the action front-loaded. It is efficient, though the extreme 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?

The tool is a simple two-parameter mutation with an output schema, and the schema itself carries the destructive/reversible distinction. However, with no annotations, the description leaves the agent without any behavioral context about irreversibility or permissions, so it is only minimally complete.

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

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

Schema description coverage is 100%, so both post_id and the force flag are already documented in the schema, including the permanent-delete vs trash distinction. The description's 'delete or trash' phrasing maps to force but adds no meaning beyond the schema, making the baseline 3 correct.

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/trash) and resource (WordPress post), which cleanly separates it from siblings like wordpress_delete_page, wordpress_delete_media, and wordpress_update_post. It does not, however, explicitly contrast with any sibling 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?

There is no guidance on when to use this tool versus alternatives, nor on prerequisites such as required post permissions or whether the post must exist. The agent must infer usage from the tool name alone.

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

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

The readOnlyHint annotation already establishes the safe-read profile, and the output schema covers the return shape, so the description adds essentially no behavioral context beyond what structured fields provide (no error handling for missing IDs, no auth/permission notes). It neither contradicts nor enriches the annotations.

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

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

One short sentence with the key scoping word ('single') front-loaded; nothing is padded or wasted.

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-resource read with full schema coverage, an output schema, and annotations carrying the safety profile, little more is needed. Only a small routing hint toward list_comments versus get_comment would improve it.

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 a single documented parameter, so the schema already defines comment_id. The phrase 'by ID' adds no syntax or format detail, making this the baseline case where the schema does the heavy lifting.

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

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

States a specific verb (get), resource (WordPress comment), and scope (single, by ID), which separates it from wordpress_list_comments. It does not name siblings or explicitly contrast with wordpress_get_post-style retrieval, but the intent is unambiguous.

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

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

The use case is implied: call this when you have a comment ID and need exactly one comment, rather than listing. There is no explicit when-to-use/when-not-to-use guidance or mention of prerequisites, so it stays at the minimum-viable level.

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?

readOnlyHint=true already declares this is a safe, non-mutating read, so the burden on the description is low. The description adds only the scope detail that it returns a single item rather than a collection; it says nothing about failure behavior for an unknown ID or any auth/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 tight sentence with the resource and key front-loaded and no filler. It is arguably undersized for the surrounding tool set, but every word present 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 one-parameter read tool with a full schema and an output schema already describing the return shape, this is essentially complete. The only shortfall is the absence of any routing hint toward the list/URL siblings.

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 the single parameter (media_id) is documented in the schema, so the schema carries the semantics. The description repeats "by ID" without adding format, range, or sourcing details (e.g., how to obtain a media ID) beyond what is already structured.

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 ("Get a single WordPress media item") plus the lookup key ("by ID"), so the operation is unambiguous. It does not differentiate from the adjacent siblings wordpress_list_media, wordpress_get_media_url, or wordpress_update_media, so an agent must infer the boundary from the names alone.

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

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

The phrase "by ID" weakly implies you need a known media_id, but there is no explicit when/when-not guidance and no mention of alternatives such as wordpress_list_media for discovery or wordpress_get_media_url when only a URL is needed. With 27 siblings, that omission matters.

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 readOnlyHint annotation already establishes this as a safe read, so the bar is lower. The description contributes the fact that the returned URL is public-facing, which is modest added context, but says nothing about behavior for private/draft media, permissions, or failure modes.

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 that front-loads the purpose with zero filler. It is appropriately sized, though it is so brief that it could have afforded one clause on when to prefer it over adjacent media tools.

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?

An output schema exists, so return values need no explanation, and the input schema fully documents both parameters. For a simple two-parameter read tool this is nearly complete; only the missing routing guidance against sibling media tools leaves a small 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 100%, so both media_id and size are already documented with a size default of 'full' and enumerated values in the schema. The description adds no format or semantic 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 and resource: fetching the public URL of a WordPress media item. This is distinguishable from wordpress_get_media (which returns metadata), though the description never explicitly contrasts the two. Clear and specific, but no sibling differentiation.

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

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

No guidance on when to use this versus wordpress_get_media or wordpress_list_media. Nothing indicates prerequisites (e.g., that the media item must exist or be published) or when a different tool would be preferable. The context is left entirely 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?

The readOnlyHint annotation already confirms this is a safe read, so the description does not need to establish that. It does add one useful behavioral detail — 'full content' signals the complete page body is returned rather than a summary — but says nothing about permissions on unpublished/draft pages or error behavior for missing IDs.

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

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

A single front-loaded sentence with no filler, and the key qualifier ('with full content') is stated up front. It is efficient, though arguably it is minimal to the point of under-specification rather than tightly optimized.

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?

An output schema exists, so return values need not be described, and annotations cover the read-only safety profile. For a one-parameter lookup tool the description is nearly sufficient, with only the lack of sibling differentiation and error/visibility context keeping it from being 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?

With 100% schema description coverage the single parameter is already documented in the schema, and the description merely echoes it ('by ID'). Baseline 3 is correct; no additional format or constraint detail is supplied beyond the schema.

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

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

The description states a specific verb (Get), resource (WordPress page), and access key (by ID) with the scope of content returned (full content). It is clear on its own, but it never acknowledges its nearest sibling wordpress_get_post, nor does it differentiate itself from that tool beyond the resource noun.

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?

Usage is only implied: the resource name tells an agent this is the page-side counterpart to wordpress_get_post, and 'by ID' indicates the lookup key. There is no explicit when-to-use statement, no mention of alternatives, and no note about what to do when only a slug is known.

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?

readOnlyHint=true already establishes the safe read profile, so the description carries a lighter burden. It adds useful payload context ('full content', implying complete post body rather than a summary), but says nothing about permissions, drafts vs. published visibility, or error behavior for invalid IDs.

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

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

A single sentence with zero filler, front-loading the verb and resource immediately. Nothing could be trimmed without losing meaning.

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

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

For a one-parameter read tool with an output schema that already describes the return shape, the description covers what an agent needs to select and invoke it. Only the absence of sibling routing keeps it short of 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 the single post_id parameter is fully documented in the schema, so the baseline is 3. The description's 'by ID' merely restates the parameter rather than adding format or constraint detail beyond what the schema provides.

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 ('Get a single WordPress post by ID') and scopes the payload with 'full content'. This implicitly distinguishes it from list_posts and search_posts, though it never names those siblings 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' implies the tool is for direct retrieval when an identifier is known, and 'single' rules out bulk listing, but there is no explicit when-to-use statement or reference to alternatives like search_posts or get_page.

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 already declare readOnlyHint=true, so the safety profile is covered. The description adds nothing beyond the name: no note on whether revisions can be restored, what fields come back, or any permission/visibility constraints. With annotations carrying safety, minimal added value warrants a low score.

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 no waste. It is front-loaded and clear, though it is so terse that it forgoes any structuring or routing 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?

An output schema exists, so return values need not be explained, and annotations cover the safety profile. For a simple two-param read tool this is minimally adequate, but the absence of any usage or relationship-to-siblings guidance leaves a 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 100%, so both parameters are documented in the schema ('Post ID', 'Revision ID'). The description adds no syntax or semantic detail beyond what the schema provides, which is the baseline 3 case.

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: 'Get a specific revision of a WordPress post.' This clearly distinguishes it from wordpress_list_revisions, but it doesn't explicitly name or reference that sibling to sharpen the distinction.

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

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

No when-to-use guidance is provided. It never states that this requires both a post_id and a revision_id, nor points to wordpress_list_revisions as the way to discover valid revision IDs, nor contrasts with wordpress_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?

The readOnlyHint annotation already establishes this as a safe read operation. The description adds a brief list of returned data, but it does not go beyond annotations or the output schema to describe auth needs, rate limits, or 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?

Two short sentences, front-loaded with the tool's action and followed by return details. No filler or redundancy in the prose itself.

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 no-parameter, read-only tool with an output schema and readOnlyHint annotation, the description is sufficient. It could be slightly richer by clarifying its relationship to wordpress_test_connection, but it covers the core operation.

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

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

The tool takes zero parameters, so parameter semantics carry no burden. The empty schema is consistent with the description, and the baseline for zero-param tools is 4.

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

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

The description states a specific verb and resource: 'Get WordPress site information,' and lists returned fields. It is clearly distinguishable from most siblings, though it does not explicitly contrast itself with wordpress_test_connection or other read 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 prerequisites, and no alternatives named. The tool's purpose is implied by 'Get site information,' but an agent receives no explicit routing advice.

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

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

readOnlyHint=true already declares the safe-read profile, and the description adds nothing on top of it — no note about pagination defaults, result ordering, or whether the list is complete or filtered. It neither contradicts nor enriches the annotations.

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

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

A single short sentence with zero filler and the purpose front-loaded. It is efficient, though it is arguably too terse to earn a 5.

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

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

An output schema exists so return values need no explanation, and annotations cover safety, leaving the description merely adequate. It is minimally viable for a simple read-only list tool but adds no disambiguation against the many other list_* siblings.

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 page, search, and per_page are already fully documented in the schema. The description adds no format or behavior detail beyond that, which is the baseline-3 case.

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 + WordPress categories), which distinguishes it from siblings like wordpress_list_tags and wordpress_list_posts. It does not explicitly name an alternative or scope, but the resource noun alone is discriminating 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 gives no when-to-use context, no mention of pagination, and no guidance on choosing this over wordpress_list_tags or wordpress_search_posts. Nothing beyond the bare purpose is offered.

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 already declare readOnlyHint=true, so the safe-read profile is covered structurally. The description adds only the vague phrase 'with filtering' and discloses nothing beyond that, such as pagination limits or default result ordering. Little value beyond the annotation.

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. It is efficient, though bordering on under-specification rather than genuinely informative brevity.

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

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

Seven parameters and a read-only annotation are fully covered by schema and annotations, and an output schema exists so return values need not be explained. The description is minimally adequate but leaves filtering behavior and result semantics entirely to 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?

Schema description coverage is 100% with seven well-documented parameters (page, post, status, search, orderby, etc.). Per the baseline rule, the schema carries the parameter burden and the description's generic 'filtering' adds no syntax or format 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?

States a specific verb (List) and resource (WordPress comments) with a scope qualifier (filtering). It is distinguishable from write-oriented siblings like wordpress_create_comment or wordpress_delete_comment, but it does not differentiate itself from wordpress_get_comment or the 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?

The description says nothing about when to use this tool versus alternatives such as wordpress_get_comment or wordpress_search_posts-like siblings. No prerequisites, no context, no exclusions are given.

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

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

The readOnlyHint annotation already tells the agent this is a safe read, so the description's burden is light, but it still adds essentially nothing beyond that — no note on pagination behavior, default ordering, or rate limits. Only "with filtering" hints at behavior, which the schema already conveys via mime_type/media_type/search.

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, front-loaded sentence with no filler. It is efficient, though the brevity comes at the cost of useful detail rather than being tight because everything necessary was already said.

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 an output schema present and full parameter documentation, return values and inputs need no explanation in the description. What is missing is routing context — when to use this vs. wordpress_get_media or wordpress_search_posts equivalents — leaving the definition only minimally complete for its role in a 29-tool set.

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 seven parameters (page, per_page, order, orderby, search, mime_type, media_type) are fully self-documented. The description adds no extra semantics such as valid mime_type formats or ordering defaults, 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?

The description states a specific verb+resource ("List WordPress media items"), which cleanly separates it from wordpress_get_media, wordpress_upload_media and the other media siblings. However, it never clarifies scope (all media vs. filtered subsets) or why one would pick this over its siblings, so it stops short of full sibling differentiation.

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

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

"with filtering" gestures at the use case but gives no explicit when-to-use guidance, no exclusions, and no mention of alternatives such as wordpress_get_media for a single item. An agent must infer everything from the schema.

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

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

The readOnlyHint annotation already establishes this is a safe read operation, so the behavioral burden is lighter. The description adds nothing beyond that: no pagination behavior, no return-shape context, no ordering of revisions, and no note on 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 zero waste, front-loading the verb and resource. Nothing is bloated or buried.

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

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

For a simple read-only list tool with an output schema and 100% parameter coverage, the description is minimally adequate. It omits any routing context against the similarly named wordpress_list_revisions, which is the main gap an agent would 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?

Schema coverage is 100% and the single page_id parameter is described as 'Page ID'. The description adds no meaning beyond the schema (e.g., where to obtain page_id or what happens with an invalid one), 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 (List) and resource (revisions for a WordPress page), which is clear. However, it doesn't differentiate from the sibling wordpress_list_revisions, which presumably lists revisions by other target types, so the agent must infer the distinction from the tool name alone.

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

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

No guidance on when to use this versus wordpress_list_revisions or wordpress_get_revision. No mention of prerequisites or alternatives. Usage is implied only by the tool name and one-line purpose.

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 already declare readOnlyHint=true, and the output schema covers returns, so the bar is lower. The description adds only 'filtering and pagination,' which restates the schema rather than disclosing anything new (e.g., default status scope, whether drafts are included, pagination limits).

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. It is compact, though the brevity edges into under-specification rather than optimal density.

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 an output schema, full param coverage, and a readOnly annotation, much of the burden is carried structurally, so the thin description is survivable. What's missing is routing relative to the overlapping list/search siblings, which the structured fields cannot supply.

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 seven parameters are already documented with defaults and value hints in the schema. The description mentions 'filtering' generically but adds no syntax or semantics beyond the schema, which is the expected baseline when the schema does the heavy lifting.

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

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

States a specific verb and resource ('List WordPress pages') with the added scope of filtering and pagination, so the agent knows it's a read/listing operation. However, it never distinguishes itself from siblings like wordpress_list_posts or wordpress_search_posts, which could plausibly cover the same filtering role.

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

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

No when-to-use, when-not-to-use, or alternative routing is provided. The agent is left to infer whether filtered listing should go here or to wordpress_search_posts, even though that sibling exists and overlaps.

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 already declare readOnlyHint=true, so the safety profile is covered. Beyond that, the description discloses nothing behavioral: no note on the 100-item per_page ceiling, default page size, authentication requirements, or what the paginated response contains. It effectively restates the schema's filtering/pagination surface.

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 filler, and it leads with the verb and resource. It is efficient, though the brevity comes at the cost of the routing and behavioral 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?

An output schema exists, so return values need not be explained, and annotations cover the read-only nature. However, for a tool in a dense namespace with a near-duplicate search sibling, the absence of any disambiguation or pagination/limit context leaves a meaningful 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 100%, so all eight parameters (page, per_page, order, orderby, search, status, tags, categories) are already documented in the schema. The description's mention of 'filtering and pagination' adds no syntax, 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 (List) and resource (WordPress posts) plus the capabilities it covers (filtering, pagination). It is clear on its own, but it does not distinguish itself from the close sibling wordpress_search_posts, which an agent could reasonably confuse with keyword-based listing.

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 given. With siblings like wordpress_search_posts, wordpress_get_post, and wordpress_list_pages in the same namespace, the description should say when listing is preferred over searching or fetching a single post, and it does not.

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

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

readOnlyHint=true already tells the agent this is a safe read. The description adds nothing beyond confirming it lists revisions, which the name already implies. No pagination, ordering, or output details mentioned, though an output schema exists.

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

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

A single, front-loaded sentence with no filler. Appropriately sized for a simple one-parameter read 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 readOnly annotation and a full output schema, the safety and return shape are covered. The main gap is routing guidance relative to wordpress_get_revision / wordpress_list_page_revisions, which the description doesn't provide.

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% (post_id documented). The description adds no meaning beyond the schema's 'Post ID' description. 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?

Clear verb (List) and resource (revisions) scoped to a Wordpress post. Distinguishable from siblings like wordpress_get_revision (singular) and wordpress_list_page_revisions (pages), though it doesn't explicitly state that distinction.

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

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

No guidance on when to use this versus wordpress_get_revision or wordpress_list_page_revisions. The agent must infer from naming 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?

Annotations already declare readOnlyHint=true, so safety is covered. The description adds nothing beyond that — no pagination behavior, no note on what "available" means (published vs. all), and no hint about filtering, so it contributes essentially no behavioral context.

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

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

A single short sentence with zero filler and the verb-resource pairing front-loaded. It is efficient, though its brevity borders on under-specification rather than accomplished concision.

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?

An output schema exists, so return values need not be described, and the fully-documented schema covers the parameters. However, for a paginated list tool the description omits any mention of paging or filtering behavior, leaving it only minimally adequate.

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%: page, search, and per_page are each documented with type, default, and constraint (max 100). With the schema doing the heavy lifting, the baseline of 3 applies and the description adds no parameter meaning on top.

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?

"List available WordPress tags" names a specific verb (list) and resource (WordPress tags), so the operation is unambiguous. It does not differentiate itself from the similar sibling wordpress_list_categories, but the resource noun is explicit enough for selection.

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 when-to-use guidance, no mention of the sibling list_categories and how this differs, and no prerequisites or exclusions. 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. It does not disclose whether trashing/spamming is reversible, what permissions are required, or what side effects (notifications, visibility changes) occur — significant omissions 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 efficient, front-loaded sentence with no wasted words. It is appropriately sized, though the brevity comes at the cost of the missing guidance 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?

An output schema exists so return values need not be explained, and the schema covers both parameters. However, with no annotations and no usage guidance for a mutation tool that overlaps with update/delete siblings, the definition is only minimally 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%, including the enumerated action values, so the schema already documents both parameters fully. The description adds no syntax, format, or semantic detail beyond what the schema provides, making the baseline 3 appropriate.

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

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

The description states a specific verb and resource ('Moderate a WordPress comment') and hints at the mechanism ('changing its status'). However, it does not distinguish this tool from the closely related siblings wordpress_update_comment and wordpress_delete_comment, leaving the agent to guess whether moderation is a distinct 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 guidance on when to use moderation versus update_comment or delete_comment, nor any statement of prerequisites or exclusions. The agent is left to infer usage 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 already declare readOnlyHint=true, so the safety profile is covered and the description need not restate it. The phrase 'in title and content' adds real behavioral context by disclosing which fields are matched, but nothing is said about pagination or result ordering beyond what the schema implies.

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. Every clause ('by keyword', 'in title and content') carries 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?

An output schema exists, so return values need no explanation, and the schema fully documents the three parameters. The description covers the essential search semantics; only the absence of any sibling routing keeps it short of complete.

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

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

Schema description coverage is 100%, so keyword, page, and per_page are all documented in the schema; the baseline is 3. The description's only addition is clarifying that the keyword matches title and content, which is modest value beyond the schema.

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

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

States a specific verb ('Search') and resource ('WordPress posts') plus the scope of the search ('in title and content'). This distinguishes it functionally from wordpress_list_posts and wordpress_get_post, though it never names a sibling to make the boundary explicit.

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

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

The verb 'search' implies when to reach for it versus listing or fetching, but there is no explicit when-to-use/when-not statement and no reference to wordpress_list_posts as the alternative for unfiltered enumeration. Usage is implied rather than guided.

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 already declare readOnlyHint=true, so the non-mutating nature is covered. The description adds useful context that the call verifies credentials and returns a connection status, but says nothing about failure modes (e.g. whether auth errors are returned as a status or thrown) or rate limits.

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, front-loaded sentences with no filler. The second sentence slightly overlaps the first ('Test connection' vs 'returns connection status') but still adds the credential-verification angle, so it largely 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?

With zero parameters and an output schema present, the description need not explain return values, and it is complete for a simple connectivity probe. The only shortfall is the absence of any usage context for when to invoke it relative to the CRUD siblings.

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 no parameters, so the baseline of 4 applies. There is nothing for the description to disambiguate, and it correctly does not invent 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 states a specific verb ('Test connection') and resource ('WordPress REST API'), and the second sentence clarifies the check is about credentials and connection status. It is implicitly distinguishable from every sibling, none of which test connectivity, though it never explicitly contrasts itself with them.

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

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

Usage is only implied: 'verifies API credentials' suggests it should be called when validating configuration before other operations. There is no explicit when-to-use statement, no prerequisites, and no named alternatives, leaving the agent to infer the 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 does not meet it. It says 'update' but never discloses that this is a mutation, what permissions are required, or whether fields left null are preserved or cleared — a meaningful ambiguity given all three parameters are nullable.

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, front-loaded verb+resource, zero filler. It is terse rather than bloated; the shortfall is under-specification, not verbosity.

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

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

An output schema exists, so return values need no explanation, and the schema fully documents the parameters. But for a no-annotation mutation tool sitting beside wordpress_moderate_comment and wordpress_delete_comment, the description omits the safety and scope context an agent needs to choose correctly.

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

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

Schema description coverage is 100% and each parameter carries its own description (including the status vocabulary), so the schema does the heavy lifting. The description adds nothing beyond the schema, which lands at the baseline for high 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 and resource ('Update an existing WordPress comment'), which is unambiguous on its own. However, it does nothing to distinguish itself from siblings like wordpress_moderate_comment, which also alters comment state, or wordpress_delete_comment, so the agent gets no differentiation signal.

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 competing wordpress_moderate_comment tool, which overlaps with status changes (approved/hold/spam/trash). The agent must infer from the schema alone which tool handles moderation vs. editing.

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. It doesn't say whether this requires auth, whether changes are reversible, whether metadata is replaced or merged, or what happens to unspecified fields. The only behavioral signal is the word 'Update' implying mutation, and no output information is given despite a mutation tool needing to describe its effect.

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, front-loaded sentence with no waste. It could be slightly more informative, but it is appropriately sized and 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 5-parameter mutation tool with no annotations and no output schema details in the description (though a schema exists), the description is far too thin. It omits usage context, behavioral traits, and doesn't compensate for the lack of annotations. An agent would need to infer most operational details.

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

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

Schema description coverage is 100%, so the schema already documents all five parameters (title, caption, alt_text, media_id, description) with their meanings. The description adds no parameter information beyond what the schema provides. Baseline 3 for high coverage 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 (Update) and resource (WordPress media item metadata), which is clear enough. However, it does not differentiate from siblings like wordpress_update_post or wordpress_update_comment beyond the resource name; there's no mention of what distinguishes metadata updates from e.g. replacing the media file itself.

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, and no mention of alternatives. It doesn't say when to use this vs. wordpress_upload_media (re-upload) or wordpress_get_media. No exclusions or 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 behavioral burden, yet it discloses nothing about partial-update semantics (whether omitted fields are left untouched or nulled), required capabilities, or reversibility. The single word 'existing' is the only implicit precondition offered for an 11-parameter 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 single sentence is front-loaded and wastes no words, which is a virtue. But its brevity reflects under-specification rather than disciplined concision, leaving essential 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?

For an 11-parameter mutation tool with no annotations, the description is far too thin. An output schema exists, so return values need not be explained, but the agent still lacks mutation semantics and prerequisite information 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%, so every parameter (date, slug, title, content, status, etc.) is already documented in the schema with its own 'New X' description. The description adds no syntax, format, or defaulting detail beyond what the schema provides, 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?

The description states a specific verb ('Update') and resource ('an existing WordPress page'), making the core action unambiguous. However, it offers no differentiation from siblings like wordpress_update_post or wordpress_update_media, so it lands just short of a 5.

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

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

There is no guidance on when to use this tool versus alternatives such as wordpress_create_page or wordpress_update_post, nor any stated preconditions beyond the implicit 'existing' page. The agent must infer all usage context 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 and delivers almost nothing. "Update" implies mutation, but it never states permission requirements, whether the update is partial (all non-post_id fields are null-defaulted), or what happens to fields left unset. With an output schema present, return values need not be explained, but the mutation semantics remain undisclosed.

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

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

A single efficient sentence with zero waste, and the verb/resource are front-loaded. It is on the sparse side rather than bloated, so size is not the problem – content is.

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 11-parameter mutation tool with no annotations, the description is far too thin. With no safety profile, no partial-update behavior described, and no usage context, an agent lacks what it needs to call this correctly, even though the output schema covers 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 coverage is 100%, so the schema fully documents all 11 parameters (date, slug, tags, title, status, content, excerpt, post_id, categories, post_format, featured_media). The description adds no syntax, format, or validation detail beyond that, which is the correct baseline when the schema does the heavy lifting.

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

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

States a specific verb and resource ("Update an existing WordPress post"), which is clear on its own. It does not, however, differentiate from siblings like wordpress_create_post or wordpress_update_page, nor indicate scope (e.g., partial vs. full update) – the agent must infer this from 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 when-to-use guidance, no exclusions, and no mention of the natural alternative (wordpress_create_post for new posts). The agent has to figure out from the name alone that this is for modifying existing posts identified by post_id.

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

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

No annotations are provided, so the description carries the full burden, and it does disclose genuinely non-obvious behavior: the file is read directly from disk instead of via base64 payloads, and under containerization the path resolves to the container filesystem with a specific host mount point. It omits auth/permission requirements and any size or duplicate-filename behavior, so it is not complete.

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?

Front-loaded with the core action, then the rationale, then a clearly labeled CONTAINER NOTE. Slightly redundant, since "Provide an absolute path to the file" restates the first and third sentences, but the total length is proportionate to the caveat being conveyed.

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?

An output schema exists, so return values need not be explained, and the description covers the tricky parameter-resolution case that schema text alone cannot. Auth requirements and limits are unstated, which is the main remaining gap for a write tool with no annotations.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds meaning the schema does not: it explains how file_path resolves under containerization and maps the host upload directory to /tmp/mcp-uploads/ inside the container, which is essential for passing that parameter 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 and resource ("Upload a media file to WordPress") plus the input modality (from a local file path). This cleanly separates it from the sibling read/manage tools (wordpress_list_media, wordpress_get_media, wordpress_update_media, wordpress_get_media_url).

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?

Gives clear context for how the tool should be invoked (provide an absolute local path; the file is read from disk rather than passed as base64) and warns about the container-specific case. It does not name an alternative tool or state when not to use this one, which is the only gap.

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