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

Discloses two-call confirmation and re-reading behavior beyond annotations. Does not mention all side effects but adds context with openWorldHint.

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

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

Single sentence with behavioral note; concise and front-loaded. Could be slightly more structured.

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

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

Output schema exists, so return values are covered. But description omits how to use settings and confirmation; for a creation tool with nested objects, more context would help.

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 low (33%), and description adds no parameter-level details beyond schema. Key parameters like confirmation and settings are unexplained.

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

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

Describes specific verb 'Append' and resource 'widget to parent container'. Includes behavioral detail (re-reads, two-call confirmation). Clearly distinguishes from siblings like delete_widget, move_widget.

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 usage via parent container types, but no explicit guidance on when to use vs. alternatives or when not to use.

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

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

Annotations declare destructiveHint=true, and the description complements this by stating it backs up the target first, which is a key behavioral trait. There is no contradiction, and the description adds value beyond annotations by specifying the backup 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 sentences, no wasted words, front-loaded with the core action. Each sentence adds essential 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?

Given the tool complexity (5 parameters, 2 required, output schema exists), the description covers the main action and backup behavior. However, it omits details on parameters like confirmation and site_id, which are not covered by schema descriptions. Still, for a template application tool, it is nearly complete.

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

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

Schema coverage is only 20%, with only source_id having a description. The tool description does not elaborate on other parameters like site_id, target_page_id, backup_to_file, or confirmation. The statement 'Backs up the target first' is ambiguous regarding whether backup_to_file controls this behavior. Parameter semantics are insufficient.

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

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

The description clearly states the action: copy _elementor_data and _elementor_page_settings from a source to a target page. It specifies the resources (source template/page, target page) and the verb 'apply', which distinguishes it from sibling tools like import_elementor_template or duplicate_elementor_page.

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 includes 'Use to apply a section/page template to an existing draft,' providing a clear use case. However, it does not explicitly mention when not to use this tool or suggest alternatives, which would strengthen guidance given the large set of sibling tools.

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

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

Annotations already indicate destructiveHint=true and idempotent=false. The description adds critical behavioral details: the two-call flow, dry-run outputs (match_count, total, confirmation_token), and that apply iterates pages with auto-backup, validate, and flush. No contradiction with annotations.

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

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

The description is three sentences, front-loaded with purpose, and every sentence adds value. It is efficiently structured with key information in minimal words.

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

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

Given the tool's complexity (6 parameters, output schema exists), the description covers the flow and behavior but misses parameter details and error/limitation info. It is 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 0%, and the description does not explain any parameters (site_id, widget_type, case_sensitive, confirmation). It only indirectly mentions confirmation_token from dry-run, but does not clarify the confirmation parameter or others. This is a major gap.

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

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

The description clearly states the tool finds and replaces plain text on every Elementor page on a single site. It distinguishes itself from siblings like wp_search_replace by emphasizing per-page granularity and no-SSH requirement.

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 explains the two-call flow (dry-run then apply) and compares to wp_search_replace (slower but no SSH, per-page granularity). It provides clear context for when to use this tool, though it does not explicitly state when NOT to use it.

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

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

Annotations already indicate readOnlyHint and idempotentHint, confirming safe, idempotent behavior. The description adds value by explaining the tool fetches versions from each site and compares them against wordpress.org, flagging outdated ones. This provides behavioral context beyond annotations.

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

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

The description is extremely concise: two sentences plus a lead phrase. Every sentence adds essential information: the overall purpose, the method (fetch and compare), and the output action (flag outdated). No wasted words.

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

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

Given the tool has one optional parameter and an output schema exists, the description provides adequate context. It covers the input (site_ids optional, defaults to all), the action (check versions), and the purpose (identify outdated). It lacks mention of potential rate limits or output format, but the output schema fills that 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?

The description hints that the tool operates on all sites ('Fleet-wide') and the parameter is an optional array to specify site IDs. However, it does not explicitly explain that omitting site_ids checks all sites or that providing them filters to those sites. With 0% schema coverage, more detail would improve clarity.

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

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

The description clearly states the tool's purpose: performing a fleet-wide audit of Elementor versions by fetching installed versions and comparing against the latest from wordpress.org, flagging outdated installs. This is specific, uses a clear verb-resource structure, and distinguishes it from sibling tools like list_elementor_pages or check a single site.

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

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

The description implies the tool is for fleet-wide version checking but does not explicitly state when to use it versus alternatives. It lacks guidance on scenarios where this tool is not appropriate or mention of related tools that might be better for individual site checks.

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 indicate read-only and idempotent behavior. The description adds that it uses SHA-256 and size delta, confirming non-destructive, deterministic operation with no side effects.

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

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

Two concise sentences front-load the core functionality and alternatives. Every sentence adds value without redundancy.

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

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

Given the presence of an output schema, the description adequately covers purpose, method, and alternatives. Minor gap: could mention if the result is a boolean or detailed diff, but output schema likely covers this.

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

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

Schema description coverage is 0%, and the description does not elaborate on the parameters beyond their names. While names are self-explanatory, the description should clarify expected format (e.g., absolute vs relative path) or file types.

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

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

The description clearly states the tool compares two screenshot files via SHA-256 hash and size delta, distinguishing it from pixel-diff tools. The verb 'compare' and resource 'screenshot files' are specific, and it is unique among siblings.

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

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

Provides explicit usage context: 'Quick way to spot whether a page changed visually after an edit.' Also guides to alternatives: 'For pixel diffs, use a dedicated tool externally.'

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

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

The description adds behavioral details beyond annotations: it backs up before deleting and re-reads to confirm deletion. No contradiction with 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?

Two sentences, front-loaded with purpose, no wasted words.

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

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

Given the output schema exists and annotations are provided, the description is mostly complete but could mention what happens if confirmation is missing or incorrect.

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

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

With 0% schema description coverage, the description should compensate, but it only indirectly mentions confirmation and 'by id' for widget/page, leaving site_id and details unexplained.

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

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

The description clearly states 'Remove a widget from a page by id' with a specific verb and resource, distinguishing it from sibling tools like duplicate_widget or move_widget.

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?

It mentions 'Two-call confirmation' and 'Backs up before deleting; re-reads to confirm' which provides clear usage context, though it doesn't explicitly list when not to use it versus 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?

The description discloses key behavioral details: it creates a new draft page, copies specific fields (_elementor_data, etc.), and flushes CSS. This goes beyond the annotations (destructiveHint: false, idempotentHint: false) by explaining the side effects, though it could mention the need for permissions.

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

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

The description is extremely concise with two sentences. Every word serves a purpose; no fluff. It is front-loaded with the main action and quickly lists the copied fields and side effect.

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 duplication tool with 4 parameters and an output schema, the description covers the main aspects: what is duplicated, the action taken, and the CSS flush. It lacks mention of prerequisites (e.g., Elementor must be active) or error states, but these are minor given the output schema exists.

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 low (25% for new_title). The description adds meaning by stating that new_title defaults to '<original> (Copy)' and that the page is created as a draft, partially compensating for missing schema descriptions. However, it does not explain site_id or source_page_id beyond the schema.

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

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

The description clearly states the tool's purpose: 'Duplicate an Elementor page within the same site.' It specifies the verb (duplicate), resource (Elementor page), and context (same site), distinguishing it from siblings like duplicate_widget or list_elementor_pages.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any prerequisites, error cases, or scenarios where another tool might be more appropriate, such as when duplicating a page without Elementor data.

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

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

The description adds context beyond annotations: 'Two-call confirmation' and 'Re-reads to confirm' reveal the tool's verification pattern. It also states non-destructive behavior ('clone gets a new id'), consistent with destructiveHint=false. No contradiction with annotations.

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

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

The description is short (3 sentences) and front-loads the key purpose. However, it mixes behavioral notes and could benefit from structured bullet points. It is efficient but slightly informal.

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

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

Given the 4 parameters with zero schema coverage, the description is incomplete. It does not explain the 'confirmation' parameter or the two-call flow in detail. An output schema exists, so return values are covered, but parameter semantics are lacking.

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

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

Schema description coverage is 0%, and the description adds no explanation for any parameter (site_id, page_id, widget_id, confirmation). It does not clarify the role of 'confirmation' or how the parameters relate to the duplication logic. The description fails to compensate for the lack of schema descriptions.

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

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

The description clearly states the verb 'duplicate', the resource 'widget', and key actions: 'in place (right after the original)', 'clone gets a new id', 're-reads to confirm', and 'two-call confirmation'. This distinguishes it from siblings like delete_widget, move_widget, etc.

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

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

No guidance is provided on when to use this tool versus alternatives. Siblings like duplicate_elementor_page exist but no contrast is given. The description implies its use for duplication but lacks context for selection.

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

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

Description discloses safety mechanisms: auto-backup, JSON validation, auto-rollback on failure, and CSS flush. Annotations already mark destructiveness; the description adds context beyond them. No contradiction. Adds good value, but could mention side effects like page reload or timeout. Score 4.

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

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

The description is two sentences, front-loading the purpose and then detailing the flow. It is concise but the second sentence is dense, packed with multiple features. Could be improved with bullet points, but overall efficient for the amount of information provided.

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 but is not described. Parameter coverage is low. The description covers the two-call flow well but leaves gaps in parameter details and output interpretation. Adequate for a moderate-complexity tool, 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 13% (low), and the description does not explain individual parameters such as site_id, page_id, find, replace, widget_type, case_sensitive, backup_to_file, or confirmation. Only 'confirmation_token' is implied in the flow. The description fails to compensate for the schema gap, resulting in poor parameter understanding.

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

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

Description explicitly states 'Find/replace plain text in every widget on one page,' with a specific verb (find/replace) and resource (widget text on a page). It clearly distinguishes from sibling tools like 'bulk_find_replace_site' (site-wide) and 'fleet_find_replace' (fleet-wide), earning a top score.

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

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

Description outlines a two-call flow (dry-run then apply), explaining the confirmation token requirement. It implies when to use (after dry-run) but does not explicitly state when not to use or mention alternatives. The context is clear, but lacks explicit exclusions, so score 4.

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 and idempotentHint, so the description builds on these by specifying the output is a portable JSON object and intended for import. No contradictions; adds context about the tool's behavior beyond annotations.

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

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

The description is two sentences, front-loaded with the action and resource, and contains no extraneous information. Every word serves a purpose.

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

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

The tool is simple with 2 parameters and an output schema. The description adequately covers purpose and output use case, but fails to describe parameters. Given the output schema exists, completeness is moderate but missing parameter guidance.

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

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

Schema description coverage is 0%, and the description does not mention either parameter (site_id, template_id) or their roles. This is a major gap; the description adds no meaning beyond what the schema provides.

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

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

The description clearly states the verb (export), the resource (Elementor template), and the output format (portable JSON object). It also explicitly ties the output to the sibling tool import_elementor_template, distinguishing its purpose.

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

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

The description gives clear context: use when exporting an Elementor template for reuse on another site, with output directed to import_elementor_template. It does not explicitly state when not to use or list alternatives beyond the import tool, but provides sufficient guidance.

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

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

Annotations mark destructiveHint=true and idempotentHint=false. Description adds that it follows the same flow as bulk_find_replace_site but iterates across sites, returns summaries, and requires a dry-run step. No contradictions; adds valuable 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?

Three sentences front-loaded with purpose, usage guidance, and warning. Efficient but could briefly list key parameters for improved scannability.

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?

Covers high-level operation and return summaries (output schema exists). Lacks detail on parameters and exact flow per site, which is important given 6 params and destructive nature.

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

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

Schema description coverage is only 17%. Description does not explain most parameters (e.g., find, replace, case_sensitive, widget_type, confirmation) beyond implying 'find/replace plain text' and mentioning 'site_ids' as subset. Fails to compensate for low 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?

Description clearly states it performs find/replace plain text across every Elementor page of every site, contrasting with bulk_find_replace_site. It highlights the scope (across sites) and output (per-site + grand-total summary), making it distinct from siblings.

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

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

Explicitly instructs to dry-run first then apply, and advises using sparingly as 'the nuclear option'. This provides clear when-to-use and caution, differentiating from alternatives.

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

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

Annotations indicate non-destructive and non-idempotent behavior. The description clarifies the creation of a new library entry, aligning with annotations. No contradiction, and the description adds useful context about the input format.

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

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

Two concise sentences that front-load the action and purpose. No extraneous words, every sentence adds value.

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

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

Given the presence of an output schema and annotations, the description adequately covers the main purpose and input. It could mention side effects or prerequisites (e.g., site_id required or not), but overall it is 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 coverage is 0%, so the description must compensate. It only explains portable_json as the output of export_elementor_template, but site_id and override_title are left undefined. This partial coverage is insufficient for a 3-parameter tool.

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

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

The description clearly states the action (import), the resource (portable template JSON), and the target (new library entry in a site). It explicitly links to its counterpart export_elementor_template, distinguishing it from sibling tools like apply_template_to_page.

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 mentions 'Useful for cross-site template sync,' which gives a clear use case. It does not explicitly list when not to use or alternative tools, but the context and sibling list adequately imply the appropriate scenarios.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint. Description adds context that backups are timestamped and created by previous edits, consistent with annotations. No contradiction.

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

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

Two concise sentences: first states purpose, second gives usage guideline. No unnecessary words. Front-loaded with key information.

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

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

For a simple listing tool with output schema and annotations, description covers purpose and usage link to restore. Lacks parameter explanation, but overall sufficient for context given existing schema and 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 0% with no descriptions. Description does not explain site_id at all and only implicitly refers to page_id. Agent cannot infer meaning or constraints from description alone.

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

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

Description clearly states verb 'list', resource 'timestamped backups of a page's Elementor data', and scope 'by previous edit ops'. It distinguishes from sibling restore_elementor_backup by mentioning its purpose.

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

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

Explicitly says to use restore_elementor_backup for rolling back, indicating when to use this tool for listing. Does not provide when-not-to-use or prerequisites, but guideline is clear.

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, idempotentHint, and openWorldHint. The description adds context by specifying the filtering condition and the exact return fields (id, title, slug, status, modified date), which are helpful beyond the annotations. No contradictions.

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

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

The description is extremely concise, consisting of two short sentences. It front-loads the essential purpose and filter, then lists return fields with zero wasted words. Every part 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?

Given the tool's simplicity (3 params, no required), the description covers the return type and filtering logic. It lacks guidance on how site_id is used (though likely required by context), but annotations and output schema (not shown) supplement this. Overall adequate for a listing tool.

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

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

None of the three parameters (site_id, per_page, search) are described in the description. With schema coverage at 0%, the description fails to explain parameter usage, meaning, or constraints beyond what the schema provides (e.g., per_page default).

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

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

Description clearly states the verb 'List' and the resource 'pages built with Elementor', adding a specific filtering criterion (_elementor_edit_mode = 'builder'). It distinguishes from sibling tools like list_elementor_templates or list_widgets_in_page by focusing on pages with Elementor data.

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 explains the scope (Elementor pages via a specific meta key), giving implicit guidance on when to use it. However, it does not explicitly state when not to use or suggest alternatives among the many sibling tools, leaving some ambiguity.

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, idempotentHint, openWorldHint. Description adds behavioral context about what templates are included (e.g., Theme Builder Pro items) and the type filter, which is useful beyond 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?

Two concise sentences that front-load the purpose and list contents. No wasted words.

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

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

With an output schema existing, return format need not be described. However, it does not clarify that site_id is required (schema has no required array) or address pagination/errors. Adequate but has gaps.

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

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

Schema description coverage is 0%, so description must compensate. It only mentions the type filter, ignoring site_id and per_page. Minimal added meaning beyond 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?

Description clearly states action ('List') and specific resource ('Elementor library entries') with enumeration of included types (sections, pages, popups, etc.), distinguishing it from siblings like 'list_elementor_pages' and 'list_global_widgets'.

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

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

No explicit when-to-use vs alternatives, but the description implies usage for listing library entries and the type filter. Could benefit from contrast with similar list tools.

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

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

Annotations already indicate readOnlyHint, idempotentHint, openWorldHint. The description adds valuable context: 'editing one affects every page using it', which clarifies the shared nature of global widgets. No contradictions.

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 sentences, front-loaded with the core purpose. No fluff; every word adds meaning or context.

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

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

Given the output schema exists (not shown), the description does not need to detail return values. It explains the concept of global widgets and their cross-page effect. However, lacking details on pagination, filtering, or limits for a listing tool.

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

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

Schema description coverage is 0% and the description does not explain the 'site_id' parameter. It does not add meaning beyond the schema, failing to compensate for the lack of parameter documentation.

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

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

Clearly states 'List all global widgets on a site (Elementor library entries of type 'widget')', specifying both the resource (global widgets) and scope (site-level). Differentiates from siblings like list_widgets_in_page by noting they are shared across pages.

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

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

The description implies usage for listing global widgets but provides no explicit guidance on when to use this tool versus alternatives (e.g., list_widgets_in_page). No exclusions or prerequisites are mentioned.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the description's simple statement is consistent and sufficient for this straightforward read operation.

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

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

Two sentences, no fluff, immediate clarity on purpose and optimal usage order.

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 zero params, safety annotations, and an output schema, the description covers the essential behavior adequately; a minor improvement could be noting the absence of filters.

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

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

With zero parameters and 100% schema coverage, the description adds no param details, but the baseline of 4 applies per guidelines.

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

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

The description uses a specific verb ('List') and resource ('every WordPress site'), clearly distinguishing it from sibling tools that operate on individual sites or elements.

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 hint 'Best called first in a session' provides clear context for when to invoke this tool, though it does not enumerate alternatives or exclusions.

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

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

Annotations already indicate the tool is read-only and idempotent. The description adds value by specifying the output shape (id, type, parent path, excerpt) and a behavioral detail: only the first text setting is excerpted. This goes beyond the annotations to inform the agent about data scope.

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

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

A single sentence that efficiently packs the verb, resource, output fields, and purpose. No redundancy or irrelevant information. Every word serves a purpose.

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

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

The description explains the output fields and use case but omits details like pagination, ordering, limits, or error conditions. The tool has an output schema so return values are partially covered, but the description could have mentioned that the list is flat (no nesting) or that widget_type can filter results.

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

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

With 0% schema description coverage and 3 parameters, the description provides no information about the purpose of site_id, page_id, or widget_type. The schema itself is minimal (just types and requirements), so the agent lacks guidance on how to use these parameters. This is a significant gap.

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

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

The description clearly states the tool lists every widget in a page with specific fields (id, type, parent path, excerpt of first text setting) and explicitly ties it to a use case (spot-checking before find/replace). This distinguishes it from siblings like list_global_widgets or read_widget.

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

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

The description provides a clear use case: 'for spot-checking before find/replace'. While it doesn't explicitly compare to alternatives, it implicitly advises using this for quick inspections rather than individual widget reads or updates. The context of spot-checking differentiates it from other list tools.

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

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

Annotations indicate destructive (mutation) and non-idempotent. Description adds 'Re-reads to confirm new parent. Two-call confirmation.', providing behavioral context beyond annotations. No contradiction.

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

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

Two short sentences, no fluff, front-loaded. Every word adds value.

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

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

Output schema exists but not shown. Description covers the core behavior and re-read confirmation but omits details about the confirmation parameter and return value. Adequate but not comprehensive for a 6-param mutation.

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

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

Schema description coverage is only 17% (only position has description). Description mentions new_parent and position but does not explain site_id, page_id, widget_id, or the confirmation parameter. Fails to compensate for low schema coverage.

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

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

Description clearly states 'Move a widget to a different parent (or different position in the same parent)'. It uses a specific verb and resource, and distinguishes from sibling tools like duplicate_widget, swap_widget_type, delete_widget.

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

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

The description implies usage for moving widgets but does not explicitly state when to use this tool versus alternatives. No mention of when not to use or direct comparison to siblings.

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 indicate safe, idempotent, and external-access operations. The description adds concrete behavioral detail: it connects to a site, verifies authentication, returns user identity and version info, and mentions conditional access ('if accessible'). This goes beyond the generic annotations.

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

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

The description is a single, front-loaded sentence of 15 words. It conveys the main action immediately and includes essential details without superfluous information. Every word earns its place.

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

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

Given the simple tool (one parameter, no nested objects, output schema present), the description covers the core behavior and return values. However, it does not explain the parameter, which is a noticeable gap. The tool is functional but not fully self-contained.

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

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

Schema description coverage is 0%, so the description must compensate. It does not mention the parameter 'site_id' at all, leaving the agent to infer its meaning from the context. No format, required status, or usage details are provided, which is insufficient for a single parameter.

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

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

The description clearly states the tool's purpose: 'Verify connectivity + authentication to a WordPress site.' It specifies the verb 'verify' and the resource 'WordPress site.' It also distinguishes itself from sibling tools like check_elementor_versions by combining connectivity and authentication checks with version retrieval.

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 implied: use this to check connectivity and get version info. However, there is no explicit guidance on when to use this tool versus siblings (e.g., check_elementor_versions or list_sites) or when not to use it. The description lacks alternatives or exclusions.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and openWorldHint=true. The description adds valuable behavioral context by enumerating the specific safety checks (page existence, Elementor-build, data parsing, global widget references, lock status). There is no contradiction with annotations.

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

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

The description is a single, well-structured sentence that starts with the core purpose and lists specific checks efficiently. Every part earns its place without redundancy.

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

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

Given the presence of an output schema and the thorough annotations, the description sufficiently covers the tool's behavior. It enumerates all key validation points and implies the output will indicate pass/fail. The sibling context further clarifies its role as a pre-edit check.

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

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

Schema description coverage is 0% for the two parameters. The description does not explain the meaning of 'site_id' or 'page_id', nor how they map to the checks. It only implies page_id identifies the page but lacks details like expected format or that site_id is optional.

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

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

The description uses a specific verb 'Validate' and clearly identifies the resource 'a page is safe to edit' with a detailed list of checks. This distinguishes it from sibling tools like 'read_page_elementor' or 'update_widget_settings' that perform different operations.

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 strongly implies use before editing a page, listing conditions that must pass. However, it does not explicitly state when to avoid this tool or mention alternatives for similar validation tasks.

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

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

The description discloses important behavioral traits beyond annotations: it warns that verbose=true returns a potentially multi-megabyte full parsed tree. This adds risk awareness. Annotations already confirm read-only, idempotent, and open-world hints, and the description aligns smoothly.

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 sentences, each earning its place: the first states the primary purpose, the second adds a critical nuance about verbosity. No redundant words, front-loaded 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?

The description is sufficient given the tool's simplicity and the presence of an output schema for return value details. It covers the two operational modes and a size warning. However, it could briefly mention that the output is a JSON structure, but that is easily inferred.

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

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

The description adds meaning for the 'verbose' parameter (explaining its effect and size implications) but does not explain 'site_id' or 'page_id'. Since the input schema has 0% description coverage, the description partially compensates but leaves two parameters undocumented.

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

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

Description uses a specific verb ('Fetch') and resource ('page's Elementor data structure summary'), clearly indicating what the tool does. The addition of the verbose option further clarifies the two modes. It is easily distinguishable from sibling tools like 'read_widget' or 'list_elementor_pages'.

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

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

No guidance is provided on when to use this tool versus alternatives like 'list_elementor_pages' or 'read_widget'. There is no mention of appropriate contexts, exclusions, or prerequisites, leaving the agent to infer usage from the name alone.

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

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

Annotations already declare the tool as read-only and idempotent. The description adds value by specifying 'full settings', indicating the scope of the returned data. This is consistent and adds minimal but useful 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 concise sentences with no redundancy. Every sentence serves a purpose: the first states the action, the second provides a crucial usage hint. Efficient and well-structured.

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

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

The description covers the main purpose and gives a usage hint, but it lacks parameter details (e.g., site_id is optional, required params are page_id and widget_id). Given the zero schema coverage, more parameter guidance would improve completeness.

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

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

The input schema has 0% description coverage, and the description does not explain the parameters (e.g., which id corresponds to which field). It only mentions 'by id' without specifying that both page_id and widget_id are required. This leaves ambiguity for parameter selection.

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

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

The description clearly states the verb 'Fetch' and the resource 'single widget's full settings by id'. It distinguishes itself from sibling tools like 'list_widgets_in_page' by indicating that this tool fetches a single widget's settings.

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

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

The description explicitly advises to use 'list_widgets_in_page' to find the widget id first, providing clear usage context and differentiation from alternatives.

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

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

Annotations already provide destructiveHint=true. The description adds value by explaining the two-call flow and confirming it restores specific metadata, giving context beyond 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?

Two sentences: first states core purpose, second highlights critical flow detail. No extraneous words; front-loaded and efficient.

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?

Description covers purpose and flow but lacks parameter details needed given low schema coverage and destructive behavior. Adequate for a simple tool but incomplete for a multi-step 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 only 20% (only backup_meta_key described). The description does not explain the roles of site_id, page_id, settings_meta_key, or confirmation beyond mentioning the flow, insufficient for low 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?

Description clearly states the tool restores Elementor data and settings from a backup, and mentions a two-call flow, distinguishing it from siblings like list_elementor_backups and restore_from_file.

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

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

Description mentions a two-call flow with confirmation token, implying a specific usage pattern, but does not explicitly state when to use this tool versus alternatives like restore_from_file or list_elementor_backups.

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

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

Annotations indicate destructiveHint=true; description adds that restoration requires a JSON backup file and involves a two-call confirmation. Beyond annotations, it clarifies the backup source and process but does not fully detail destructive scope.

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 sentences, front-loaded with purpose, no extraneous content. Efficiently communicates core action and constraints.

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 4 parameters with zero schema descriptions and a destructive action, description lacks detail on optional parameters and the two-call confirmation mechanism. Insufficient for an agent to correctly invoke the tool without further guesswork.

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

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

Schema has 0% parameter descriptions; description only clarifies file_path's purpose and hints at confirmation. It fails to explain site_id or the confirmation parameter's role, leaving significant ambiguity.

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

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

Description clearly states the tool restores a page from a JSON backup file, specifying the backup source (earlier op with backup_to_file=true or fullBackup with to_file). This distinguishes it from siblings like restore_elementor_backup.

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?

Description notes the file_path requirement and mentions two-call confirmation, but does not explain when to avoid or what alternatives exist. It provides some context but lacks explicit guidance on when-not-to-use.

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

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

Annotations already provide readOnlyHint=true. Description adds important precondition: requires Chrome/Chromium binary. Does not disclose failure modes or rate limits, but dependency info is valuable beyond 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?

Two sentences, no fluff, front-loaded with core action and output. Efficient and well-structured.

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

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

Does not explain that site_id+page_id and url are alternatives. Missing parameter coverage. But output schema exists, so return value hint suffices. Overall adequate but with gaps.

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

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

Schema description coverage is only 17% (only 'url' described). Description does not explain site_id, page_id, width, height, full_page parameters. Only mentions url implicitly. Fails to compensate for low 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?

Description clearly states verb 'capture', resource 'screenshot of page frontend', and format 'PNG'. It distinguishes from sibling 'compare_screenshots' by mentioning comparison use.

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 usage for analysis or comparison via 'so the LLM can analyse it or compare against another shot'. No explicit when-not-to-use or alternative mentions, but context is clear.

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 indicate read-only, idempotent, open-world. The description adds that it aggregates multiple REST calls (useful context) and that disk space is conditional on SSH. It does not contradict 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?

Two sentences that are front-loaded with the core value proposition. No redundant words or fluff.

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

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

Given that it has an output schema (so return values are covered), the description lists key output items. It does not mention the optional parameter or its role, but for a simple tool with one param, it covers the essentials.

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

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

Schema description coverage is 0%, and the description does not explain the 'site_id' parameter at all. It only describes the output, not the input meaning or usage.

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

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

The description clearly states it provides a comprehensive site health snapshot including specific items like WP/PHP/Elementor versions, disk space, plugin count, theme info. It distinguishes itself from sibling tools like check_elementor_versions or ping_site by being an aggregated overview.

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

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

The description implies use for a broad overview but does not explicitly state when to use this tool versus others like check_elementor_versions or preflight_check. No exclusions or alternatives are mentioned.

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

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

Beyond annotations (destructiveHint=true, idempotentHint=false), the description adds critical details: 'Re-reads to confirm. Two-call confirmation.' and warns about settings not being carried over, which enhances transparency.

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

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

Three sentences, each with distinct value: purpose, key warning, and behavioral note. No extraneous information, very efficient.

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 complexity (two-call confirmation, destructive, new_settings requirement) and presence of an output schema, the description covers essential points. However, it doesn't detail the confirmation flow or the optional confirmation parameter, which could be clearer.

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

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

With 0% schema coverage, the description adds meaning to new_settings by clarifying it must be a full replacement. Other parameters like site_id, page_id are self-explanatory, so the description adds value where needed.

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

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

The description clearly states 'Replace a widget's type' with an example (heading → button), and specifies preservation of id and position, distinguishing it from siblings like update_widget_settings or delete_widget.

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?

It gives clear guidance: provide full new_settings and warns old settings are not carried over. It doesn't explicitly state when not to use or name alternatives, but the context is clear enough for an agent to differentiate.

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

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

The description discloses several behavioral traits beyond annotations: it is destructive (backs up page), non-idempotent (creates side effects), and open-world (affects external state). It details the two-call confirmation pattern, auto-flush, and verification via 'matches_requested'. This adds significant transparency that annotations alone do not provide.

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

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

The description is concise, containing two well-structured sentences. The first sentence states the core function, and the second provides important behavioral details. Every word adds value, with no redundancy or fluff.

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

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

Given the tool's complexity, the description covers the key steps: backup, validation, auto-flush CSS, re-read, and verification. It mentions the response field 'matches_requested', which is helpful. However, it could be more complete by explaining the purpose of the output schema or clarifying the role of the confirmation parameter. Overall, it is adequately informative but has minor gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the overall purpose of settings_patch (partial object) but does not detail individual parameters like site_id, page_id, widget_id, or confirmation. The mention of 'two-call confirmation' hints at the confirmation parameter but lacks specificity. Additional parameter-level descriptions would improve usability.

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

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

The description clearly states it performs a shallow-merge of a partial settings object into a widget, distinguishing it from sibling tools that add, duplicate, or move widgets. The verb 'merge' and resource 'widget' are specific, and the phrase 'shallow-merge a partial settings object' uniquely identifies the operation.

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

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

The description explains the tool's workflow (backup, validation, auto-flush, verification) but does not explicitly state when to use or not use this tool compared to alternatives. It implies use for updating widget settings with safety guarantees, but more specific guidance on prerequisites or exclusion cases would improve it.

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

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

Annotations already indicate destructiveHint=true, and the description adds the crucial two-call confirmation flow for destructive commands. It also discloses that the 'wp' prefix and '--path' are added automatically, providing behavioral insight beyond 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?

Two concise sentences that immediately convey the tool's purpose and key usage nuances. No wasted words, and critical information is front-loaded.

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

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

Given the tool's complexity—4 parameters, destructive hint, and an output schema—the description covers execution method, automatic prefix, destructive confirmation, and a usage example. It avoids explaining return values (covered by output schema) but could mention that 'site_id' is optional and how 'timeout_ms' relates to execution.

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

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

With only 25% schema description coverage, the description adds value by explaining how to format the 'args' parameter and implicitly describing the 'confirmation' parameter through the confirmation flow. However, 'site_id' and 'timeout_ms' are not elaborated upon.

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

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

The description clearly states 'Execute an arbitrary wp-cli command on a site via SSH' with specific verb and resource. It distinguishes from sibling tools by noting that prefix is added automatically and that arbitrary commands are accepted, which sets it apart from the more specialized wp_* 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 provides an example argument and notes that destructive commands require a two-call confirmation flow, giving clear context for when special handling is needed. However, it does not explicitly state when to prefer this tool over dedicated sibling tools like wp_plugin_list.

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

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

Annotations declare idempotentHint=true and destructiveHint=false, and the description adds the fallback strategy and correct usage context. No contradictions; disclosure is adequate.

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

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

Two concise sentences, front-loaded with verb and resource, no redundant information. Every sentence earns its place.

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

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

With annotations and an output schema present, the description covers purpose, strategy, and usage advice. Lacks details on failure modes or edge cases but sufficient for the tool's simplicity.

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 covers 50% of parameters (page_id has description, site_id lacks). Description does not add meaning for site_id, relying on context. Semantics partially addressed.

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

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

The description clearly states the tool flushes Elementor's CSS cache and specifies the 3-level fallback strategy, distinguishing it from siblings that manipulate content or perform other operations.

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?

Explicitly states to call after writing _elementor_data programmatically, providing clear context. Lacks explicit exclusions or alternatives but the instruction is actionable.

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 and idempotentHint, indicating safe repeated reads. The description adds useful context by specifying data source (WP-CLI) and that update_version is provided if outdated. No contradictions.

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 sentences, front-loaded with the main purpose. No filler words. Could benefit from explicitly listing parameters for better structure, but overall concise.

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

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

Given the simple tool, annotations, and existence of an output schema, the description covers the main purpose and data fields. It lacks explicit parameter descriptions and does not explain the return format beyond field names, but the output schema likely compensates.

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

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

Schema description coverage is 0%, so the description must compensate. It vaguely implies site_id by 'on a site' and mentions 'update_version (if outdated)' hinting at filtering, but does not explicitly describe the 'only_outdated' parameter or explain the parameters' meaning beyond their names.

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

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

The description clearly states the tool lists installed plugins with specific fields (name, version, status, update_version). It uses a specific verb and resource, distinguishing it from sibling tools like wp_plugin_update or wp_cli_run.

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 mentions using WP-CLI for accurate version data, hinting at why to use this tool, but it does not explicitly state when to use it over alternatives or when not to use it. No exclusions or alternatives are named.

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 indicate destructive behavior (destructiveHint=true), and the description adds the need for a confirmation token and that it uses wp-cli, providing useful behavioral context beyond annotations. No contradiction.

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

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

The description is a single, concise sentence that efficiently conveys the action and key requirement. No redundant information.

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

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

The description covers the basic purpose and a critical requirement (confirmation), but it does not clarify the role of site_id (optional or required) or the return value format, despite having an output schema. It is adequate but leaves gaps for an agent to fully understand configuration and outcomes.

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

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

Schema description coverage is only 33%, and the description does not explain the site_id or confirmation parameters. It only mentions confirmation token generically, without linking to the schema parameter. The schema provides some help for the 'plugins' parameter but overall the description adds minimal semantic value.

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

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

The description clearly states the tool updates one or more plugins to their latest version, using a specific verb and resource. It distinguishes from sibling tools like wp_plugin_list (list) and wp_cli_run (general command).

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 mentions a requirement for a confirmation token, which provides some usage context, but it does not explicitly state when to use this tool versus alternatives or when not to use it. Guidance on required parameters is minimal.

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 indicate destructive behavior. The description adds critical behavioral details: the mandatory dry-run first, the need for a confirmation token, and the default inclusion of --precise and --all-tables-with-prefix when table='all'. This significantly enhances transparency beyond annotations alone.

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

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

The description is two sentences: the first states purpose and default, the second gives critical usage instructions. Every word adds value, and key information is front-loaded.

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 description covers the essential workflow (dry-run, confirmation token) and important defaults. However, it does not explain the site_id parameter or constraints on find/replace. Since an output schema exists, return values need not be described. Overall, it provides sufficient context for safe usage but could be more thorough.

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

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

With only 14% schema description coverage, the description adds some parameter context (default table, default precise, flag behavior for table='all') but does not explain other parameters like site_id, find, replace, or confirmation. More detail would be beneficial given the low schema coverage.

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

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

The description clearly states the tool runs `wp search-replace` against wp_postmeta for updating Elementor content, providing a specific verb and resource. It mentions default table and flags but does not explicitly differentiate from sibling tools like `bulk_find_replace_site` or `elementor_find_replace`.

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

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

The description explicitly instructs to always dry-run first and requires a confirmation token for the apply call, providing clear when-to-use guidance. However, it does not mention alternative tools or scenarios where this tool should not be used.

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