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?

With no annotations, the description carries full burden: it discloses the status gate, which is genuinely useful. It says nothing about permissions, whether a revision is created, or whether the edit is reversible, and the exact-once matching rule lives only in the schema.

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 core action and followed by the constraint. No filler.

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

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

Output schema exists and params are fully documented, so the remaining gap is behavioral: for an unannotated mutation tool, it would help to know that edits touch live post content and how conflicts are handled. The status restriction covers the most important selector, making this close to sufficient.

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 including replace_all and expected_version are already documented. The description adds no syntax or format detail beyond the schema, so 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: replace text in a draft or pending post's source. The status restriction helps separate it from wordpress_edit_post / wordpress_update_post, 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?

Implies when it applies (draft or pending posts only) and adds a hard exclusion ('Refuses any other status'), but gives no positive routing instruction toward the sibling to use for published 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?

With no annotations, the description carries the full behavioral burden. It usefully discloses that this is a targeted source-text replacement rather than a whole-document overwrite, but says nothing about permission requirements, reversibility, or what happens when the text is absent or duplicated (the latter only hinted at in the schema).

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; the core mechanism is stated first and the qualifier follows immediately. Nothing could be removed without losing information.

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

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

An output schema exists and the input schema is fully described, so return values and parameter details are covered. For an unannotated mutation tool, however, the description should at least acknowledge that edits are destructive and what failure conditions look like, which it omits.

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_id, old_text, new_text, replace_all, and expected_version are already well documented, including the exactly-once matching constraint. The description adds no parameter-level meaning beyond the schema, so 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 names a specific verb and resource (replace text in a WordPress page's source) and adds a distinguishing mechanism ('without resending the page') that separates it from full-page siblings like update_page. It stops short of naming the sibling outright, so the distinction is inferred rather than 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 phrase 'without resending the page' implies the tool is for surgical edits rather than full-page rewrites, which hints at when to prefer it over wordpress_update_page. However, it never states the alternative or the condition that selects it, leaving routing to inference.

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

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

No annotations are supplied, so the description carries the full burden, and it does disclose one meaningful trait: this is a targeted patch that does not resend/overwrite the whole post. However, it says nothing about permissions, whether revisions are created, what happens when the replacement target is missing or ambiguous, or how failures surface — all relevant for an unannotated 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?

One short sentence, front-loaded with verb and resource, zero filler. Nothing in it is redundant with the schema or annotations.

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 a full output schema present and 100% parameter description coverage, the description need not explain return values or field semantics. What remains thin is the sibling disambiguation and any note about failure/conflict handling, but for a five-parameter tool whose schema already encodes the tricky constraints, it is close to 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 coverage is 100% and the schema itself is unusually rich — old_text documents the exactly-once constraint, replace_all documents the override, and expected_version documents the optimistic-concurrency check. The description adds no parameter meaning beyond that, so the baseline 3 is appropriate.

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

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

A specific verb+resource pair: 'Replace text in a WordPress post's source,' which is meaningfully narrower than a whole-post rewrite. The closing phrase 'without resending the post' implicitly distinguishes it from wordpress_update_post and wordpress_edit_draft, but neither sibling is named, so the agent must infer the boundary.

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?

'Without resending the post' hints at when this is preferable to a full update, but there is no explicit when-to-use statement, no preconditions, and no named alternative. Usage is implied rather than stated, which leaves the agent guessing between edit_post, update_post, and edit_draft.

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?

readOnlyHint=true already tells the agent this is a safe read, so the bar is lower. The phrase 'with its saved source' usefully signals the response includes raw stored markup rather than rendered content. It says nothing about behavior for a missing or trashed page ID, though non-destructive reading is fully covered by 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, front-loaded with verb and resource, with the qualifier about saved source appended. Nothing is wasted 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 single-parameter read tool with an output schema and a readOnlyHint annotation, the description covers the essential scope. The only real gap is what happens with an invalid or non-page ID, which is minor.

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 page_id parameter, so the schema does the work. The description's 'by ID' merely restates it and adds no format or sourcing detail 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 and resource ('Get a single WordPress page by ID') and adds scope ('with its saved source'). The word 'page' distinguishes it from the sibling wordpress_get_post without needing to name it 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?

No when-to-use guidance, no prerequisites, and no routing to alternatives such as wordpress_list_pages or wordpress_get_post. An agent must infer that this is the point-lookup tool and that an ID is required from elsewhere.

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 description's burden is lighter. It adds the phrase 'with its saved source', which hints at extra returned content but is left unexplained – an agent cannot tell whether that means raw HTML, revision source, or something else.

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 phrase earns its place: the verb, the singular scope, the lookup key, and the extra 'saved source' payload.

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-record read with full schema coverage and an output schema that documents return values, the description covers what is needed to call it. The only shortfall is the ambiguous 'saved source' phrase, which leaves the most distinctive part of the return contract unexplained.

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 documented in the schema. The description adds no format, range, or semantic detail (e.g. what happens with an invalid or draft ID) beyond what the schema already declares.

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') with a distinguishing scope ('single ... by ID') that separates it from list_posts and search_posts. It does not explicitly name siblings or contrast with wordpress_get_page, so it falls short of a 5.

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

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

Usage is only implied: the agent can infer this is the tool for a known post ID. There is no explicit when-to-use guidance, no statement about when to prefer search_posts or list_posts, and no mention of prerequisites or error behavior for missing IDs.

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 exist, so the description carries the full burden, yet it discloses almost no behavior: whether omitted/null fields leave values unchanged or clear them, whether content is replaced wholesale, what permissions are needed, or that writes can be rejected via expected_version. Only the edit_page routing hint adds 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?

Two short sentences, front-loaded with the action and ending with the disambiguation rule. No filler.

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

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

An output schema exists and the input schema is fully documented, but for a 12-parameter mutation with no annotations the description should at least state partial-vs-full update semantics and the expected_version guard, which it leaves entirely to the schema.

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

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

Schema description coverage is 100% and all 12 parameters (including page_id and expected_version) are documented in the schema, so the baseline of 3 applies. The description adds no semantics beyond the schema, notably nothing about null/omitted field handling.

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 page') and explicitly contrasts itself with the sibling wordpress_edit_page. An agent can distinguish the two without opening either 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?

Gives a clear routing rule: for partial content changes, use edit_page. It does not cover the converse (when update_page beats edit_page, e.g. multi-field changes), nor does it point to get_page/expected_version for the concurrency path.

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 mostly fails. It never states whether omitted fields are left untouched or cleared, that this is an irreversible write requiring edit permissions, or what role expected_version plays in conflict handling (the schema mentions it, but the description does not surface the concurrency 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?

Two short sentences, front-loaded with purpose and zero padding. But the brevity is under-specification rather than economy: for a 12-parameter mutation tool, the sentence budget is too small to be genuinely concise-and-complete.

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

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

Given a mutation tool with 12 optional parameters, no annotations, and no explanation of partial-update or null-default semantics, the description leaves the agent without what it needs to call safely. An output schema exists so return values need not be described, but the write-behavior gaps are significant.

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 one of the 12 parameters is already documented in the schema, which sets the baseline at 3. The description adds no additional meaning about partial-update semantics, null handling, or the expected_version precondition.

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') that is immediately understandable. It partially differentiates from the sibling wordpress_edit_post via the second sentence, though the boundary between them remains fuzzy since both appear to modify posts.

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

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

One explicit routing rule is given ('To change part of the content, use edit_post'), which implies update_post is a wholesale replacement. However, no guidance is offered for the many other overlapping siblings (wordpress_edit_draft, wordpress_update_page, wordpress_create_post) or for when a post should not be updated.

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.