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

Zero annotations provided, yet description discloses no behavioral traits: whether an email invitation is sent, what access level is granted, if the operation is idempotent, or error conditions (e.g., if email already has access).

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

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

Extremely concise (5 words) but underspecified given the lack of annotations and schema coverage. No redundancy, but insufficient content for the tool's complexity.

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

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

Incomplete for a collaboration-invitation tool with no output schema and undocumented parameters. Should describe the invitation flow, returned confirmation, or side effects (emails sent, account creation).

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% (both parameters undocumented). Description mentions 'site' and 'collaborator' conceptually but does not map these to `site_id` (format? UUID? slug?) or `email` (collaborator's email vs. inviter's?). Fails to compensate for missing schema documentation.

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

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

Clear verb (Add) + resource (collaborator) + target (site). Distinguishes adequately from sibling `list_collaborators` and other site-management tools. However, lacks scope clarification regarding what permissions/role the collaborator receives.

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

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

No guidance on when to use versus alternatives, prerequisites (e.g., does the collaborator need an existing account?), or expected outcomes. No mention of checking existing collaborators before adding.

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

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

With zero annotations provided, the description carries the full burden of behavioral disclosure, yet reveals nothing about side effects, idempotency, required permissions, or whether the operation triggers DNS validation. It mentions 'Add' implying mutation, but omits critical behavioral context like whether this makes the domain primary or additional.

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

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

The single sentence is front-loaded and contains no fluff, but extreme brevity becomes under-specification given the lack of annotations and schema documentation. While structurally efficient, the description is inappropriately sized for the information gaps it leaves unfilled.

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 annotations, 0% schema coverage, and no output schema, the description is incomplete. For a two-parameter mutation tool, it should explain parameter semantics, behavioral side effects, or return value expectations, but provides only the bare action statement.

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 (both 'id' and 'domain' lack descriptions), the description provides minimal semantic mapping by implying 'id' refers to a site and 'domain' is the domain to attach. However, it fails to compensate for the schema gaps by explaining formats (e.g., whether domain includes protocol), whether id is a UUID or slug, or providing examples.

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 'Add a domain to a site' is tautological—it merely restates the tool name (pressable_add_site_domain) in sentence form without adding specificity. While it identifies the verb (Add) and resources (domain, site), it fails to distinguish this tool from siblings like pressable_create_dns_record or clarify what 'add' entails (attach, map, verify?).

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 provided on when to use this tool versus alternatives (e.g., pressable_create_dns_record for DNS configuration), prerequisites (domain ownership verification requirements), or exclusions. The description states only what the tool does, not when to invoke it.

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

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

No annotations provided, so description carries full burden. States conversion targets but fails to disclose mutation side effects, reversibility (can sandbox convert back to live?), downtime implications, or data preservation guarantees. 'Convert' implies state change but lacks critical safety context for a high-stakes 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?

Single 10-word sentence is efficient and front-loaded with the action verb. No redundancy. However, brevity verges on under-specification given the tool's operational complexity and lack of supporting schema documentation.

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?

Site environment conversion is a high-risk operation requiring safety disclosures. With no annotations, no output schema, and undocumented input parameters, the description offers insufficient context for safe invocation. Should detail at minimum whether conversion is destructive or reversible.

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, description partially compensates by listing valid target_type values (staging, live, duplikit, sandbox). However, fails to document the 'id' parameter (presumably site ID) or explain conversion direction semantics/validation rules.

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?

Uses specific verb 'Convert' with resource 'site', and clearly defines valid conversion targets (staging/live/DupliKit/Sandbox). Differentiates from siblings like create_site (new creation) and restore_site (backup recovery). Could be elevated to 5 with brief context on what DupliKit/Sandbox environments represent.

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

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

Provides no guidance on when to use versus alternatives like update_site or restore_site. Omits warnings about potential data loss, downtime during conversion, or prerequisites (e.g., site state requirements). No 'when-not' exclusions provided.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure but fails to deliver. It does not state whether creation overwrites existing bookmarks, what permissions are required, what the tool returns upon success, or whether this operation has any side effects beyond creating the record.

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

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

The single sentence is efficient and unambiguous, with no wasted words. However, given the lack of supporting schema documentation and annotations, this brevity results in insufficient information transfer rather than praiseworthy conciseness.

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

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

For a 4-parameter mutation tool with no annotations, no output schema, and zero schema descriptions, the description is inadequate. It fails to explain what constitutes a bookmark, how it will be used later, or what validation rules apply to the inputs.

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 must compensate by explaining the four parameters, but it does not. While 'Bash/WP-CLI command' hints at the command and command_type parameters, it offers no guidance on the distinction between name (required identifier) and description (optional context), nor the expected format for command strings.

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 the specific verb 'Create' and identifies the resource as a 'Bash/WP-CLI command bookmark.' It effectively distinguishes this mutation operation from sibling read operations like pressable_get_bash_bookmark and pressable_list_bash_bookmarks, though it could better clarify the difference from execution tools like pressable_run_bash_commands.

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 explain that bookmarks are for saving reusable commands versus immediate execution via the run_* tools, nor does it mention prerequisites like whether a bookmark name must be unique.

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

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

With zero annotations provided, the description carries full behavioral disclosure burden but only indicates this is a write operation via 'Create'. It omits propagation timing, atomicity guarantees, permission requirements, and whether the operation is synchronous or queued.

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?

While physically brief at five words, this represents under-specification masquerading as conciseness. The single sentence adds negligible value beyond the tool name and fails to front-load critical context for a complex infrastructure operation.

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 6-parameter DNS creation tool with no output schema and complex sibling relationships, the description is grossly incomplete. It lacks zone management context, record type behavioral differences, success/failure semantics, and integration with 'pressable_list_dns_zones' prerequisites.

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

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

Schema description coverage is 0% across all 6 parameters, and the description completely fails to compensate. Critical semantics like 'zone_name' (identifier format), 'priority' (MX-specific usage), and 'ttl' (seconds vs minutes) remain undocumented despite the schema 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 'Create a new DNS record' essentially restates the tool name 'pressable_create_dns_record' with minimal expansion. While the verb and resource are clear, it fails to distinguish from sibling 'pressable_generate_email_provider_dns_records' or clarify Pressable-specific DNS zone management context.

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 provides no guidance on when to use this manual creation tool versus the automated 'pressable_generate_email_provider_dns_records', prerequisites such as existing DNS zones, or whether this tool handles duplicate record detection.

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

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

No annotations provided, so description carries full burden. States 'create' implying mutation, but lacks critical behavioral disclosure: whether operation is async, duration expectations, storage retention policies, or if filesystem/database require separate calls. Underspecified for a destructive/mutation 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?

Single sentence with no waste. Front-loaded with core action. However, extreme brevity is inappropriate given zero schema descriptions and lack of annotations—the conciseness becomes under-specification.

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

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

Severely incomplete given constraints: no schema descriptions, no annotations, no output schema, and a mutation operation. Missing parameter semantics, behavioral expectations, and return value information. Minimum viable for a 2-parameter tool, but inadequate for safe usage.

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% description coverage, requiring description to compensate. Description fails to clarify whether 'id' refers to site ID or backup ID, or explain the practical difference between 'filesystem' and 'database' backup types (e.g., when to use each).

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

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

States specific verb (create) and resource (backup) with scope ('on-demand'). However, it does not explicitly distinguish from sibling backup tools like pressable_list_backups or pressable_restore_site, though the verb 'create' provides implicit differentiation.

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

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

Provides no guidance on when to use this versus automated backups, no prerequisites (e.g., site must exist), and no warnings about potential impacts or rate limits. No alternatives or exclusions mentioned.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It identifies the operation as creation (mutation) but fails to specify idempotency behavior, what happens if the site name exists, whether creation is synchronous, or what the response structure looks like.

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

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

Extremely concise at only four words. While not padded with fluff, it is arguably underspecified given the tool complexity (4 parameters, no annotations, mutation operation). The single sentence earns its place but leaves significant explanatory gaps.

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 lack of output schema and annotations, and the presence of 4 parameters including optional configuration choices (datacenter, PHP version), the description is incomplete. It omits return value structure, error scenarios, and site provisioning side effects that would help an agent handle the response.

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

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

With 100% schema description coverage, the baseline is 3. The description mentions no parameters, but the schema adequately documents all four fields including examples for php_version and install_option. No additional semantic context (e.g., datacenter selection implications) is provided in the description.

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

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

States a clear verb (Create) and resource (WordPress site). The word 'new' helps distinguish from sibling mutation tools like pressable_update_site and pressable_restore_site. However, it omits the Pressable platform context which could help distinguish from generic WordPress site creation 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?

Provides no guidance on when to use this tool versus alternatives like pressable_restore_site (which might restore an existing site instead of creating fresh) or pressable_convert_site. No prerequisites, limits, or error conditions are mentioned.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure but fails to mention critical traits: whether deletion is permanent/irreversible, what happens if the record_id doesn't exist, or what the operation returns (success/failure).

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 of four words is appropriately concise, but 'specific' is slightly redundant and the description lacks front-loaded critical warnings appropriate for a destructive operation.

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

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

For a destructive operation with zero schema annotations and no output schema, the description is inadequate. It omits safety warnings, error conditions, and parameter relationships that would be necessary for safe agent 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 0% yet the description adds no semantic context for zone_name or record_id. While 'specific DNS record' loosely implies identification is needed, the description fails to clarify zone boundaries or ID formats, leaving parameters effectively undocumented.

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

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

The description clearly states the verb (Delete) and resource (DNS record), distinguishing it from sibling tools pressable_create_dns_record and pressable_get_dns_records. However, it stops short of describing the scope mechanism (by zone and ID) which would make it a 5.

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

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

No guidance provided on when to use this tool versus alternatives, nor any mention of prerequisites (e.g., needing to fetch record IDs via pressable_get_dns_records first) or warnings about permanent deletion.

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

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

No annotations are provided, yet the description fails to disclose critical behavioral traits: whether deletion is permanent, if it affects backups, whether it requires confirmation, or what error conditions apply. The term 'Delete' implies destruction but lacks necessary safety context for a mutation tool.

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

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

The single sentence is efficient with no wasted words, and the key action is front-loaded. While appropriately concise in form, it is insufficiently informative in substance given the high-stakes nature of site deletion.

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

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

For a destructive operation with zero annotations and no output schema, the description is dangerously incomplete. It omits permanence warnings, recovery options, and side effects that are essential for an agent to invoke this tool safely.

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

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

Schema coverage is 100% (the 'id' parameter is fully described), establishing a baseline of 3. The main description ('Delete a specific site') implicitly references the id parameter but adds no additional semantic information, syntax details, or usage examples beyond the schema itself.

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

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

States a clear verb ('Delete') and resource ('site'), immediately identifying the tool's function. However, it lacks specificity regarding what 'delete' entails (permanent vs soft delete) and does not distinguish from the sibling tool 'pressable_disable_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?

Provides no guidance on when to use this tool versus alternatives like 'pressable_disable_site' or 'pressable_restore_site'. Contains no warnings about irreversibility or prerequisites for deletion.

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

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

With no annotations provided, the description carries full burden but fails to disclose if the action is reversible (likely yes, given pressable_enable_site exists), what visitors see when disabled, or whether data is preserved.

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

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

Extremely concise at four words with no filler, though this brevity contributes to underspecification rather than efficient information density.

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

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

Given this is a state-changing mutation with multiple related sibling operations (enable, delete, maintenance mode), the single-sentence description insufficiently explains the disable state semantics or side effects.

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?

Input schema has 100% coverage with 'id' described as 'The site ID or name'. The description adds no additional parameter context, so baseline 3 applies.

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

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

States the verb (disable) and resource (site) clearly, but does not distinguish from similar sibling tools like pressable_delete_site or pressable_enable_site, nor clarify whether 'disable' means offline, suspended, or maintenance mode.

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

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

Provides no guidance on when to use this tool versus pressable_delete_site (permanent removal) or pressable_toggle_maintenance_mode (temporary maintenance state), or prerequisites like requiring site ownership.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure but fails to deliver. It does not indicate whether the change is reversible, what happens to site accessibility, or whether this operation is destructive or safe. The agent learns only that a state change occurs.

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 brief at four words, with no redundancy or filler. However, this conciseness crosses into under-specification, as the single sentence omits critical behavioral and contextual details necessary for confident tool selection.

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 state-changing tool with no output schema and no annotations, the description is inadequate. It fails to explain the 'enabled' state semantics, side effects, or success indicators. Even with only one parameter, the ambiguity surrounding the 'enable' action leaves significant gaps.

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

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

The input schema has 100% coverage with the 'id' parameter documented as 'The site ID or name'. The description adds no additional context about parameter format, valid ID patterns, or where to obtain site IDs, warranting the baseline score for high 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 states a specific verb ('Enable') and resource ('site'), but remains vague about what 'enable' entails in the Pressable context (e.g., reactivating a suspended site vs. taking it out of maintenance mode). It does not distinguish from siblings like 'create_site' or clarify the relationship to 'disable_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 provides no guidance on when to use this tool versus alternatives such as 'create_site', 'restore_site', or 'disable_site'. There is no mention of prerequisites (e.g., the site must exist and be disabled) or explicit pairing with its counterpart 'disable_site'.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. While 'Flush' implies a destructive operation, the description fails to state that cached data will be permanently cleared, that this may cause temporary performance degradation, or whether the operation is synchronous.

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 sentence with no wasted words. It is appropriately front-loaded with the action verb, though its extreme brevity contributes to informational gaps in other dimensions.

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 annotations, no output schema, and a destructive operation with 0% parameter documentation, the description is insufficiently complete. It omits critical context about the nature of object caching, side effects, and expected 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?

With 0% schema description coverage, the description partially compensates by referencing 'a specific site,' implying the 'id' parameter refers to a site identifier. However, it does not explicitly document the parameter, its format, or how to obtain valid IDs.

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 the specific verb 'Flush' and identifies the resource as 'object cache for a specific site.' It implicitly distinguishes from the sibling tool 'pressable_purge_edge_cache' by specifying 'object cache' versus edge caching, though it does not explicitly contrast the two.

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 (like purging edge cache), nor does it mention prerequisites such as site ownership or when flushing is appropriate (e.g., after code deployments).

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It fails to clarify whether 'generate' means returning record data for manual entry or automatically creating records in the zone, nor does it mention idempotency, potential overwrites, or required permissions.

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

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

The single-sentence description is appropriately front-loaded with no wasted words, though its brevity contributes to its inadequacy given the lack of supporting schema documentation.

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 schema coverage, no annotations, and unclear behavioral semantics (creation vs generation), the description is incomplete. It fails to document parameters or explain the tool's side effects.

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%, requiring the description to compensate. While it implies the 'provider' parameter by mentioning 'email provider', it completely omits documentation for 'zone_name', leaving both parameters effectively undocumented.

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

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

The description states a clear verb ('Generate') and resource ('DNS records'), and specifies the context ('for a specific email provider'). However, it does not explicitly distinguish when to use this tool versus the generic 'pressable_create_dns_record' sibling tool.

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

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

No guidance is provided on when to use this tool versus alternatives, prerequisites (e.g., existing DNS zone), or whether the generated records are returned as data versus automatically applied to the zone.

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

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

No annotations provided, so description carries full disclosure burden. It establishes this is a read operation returning a list, but omits behavioral details like whether results are cached, if action types are static, or authorization requirements. No contradictions present.

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 9-word sentence with zero redundancy. Immediately front-loads purpose with 'Get a list' followed by specific resource. Appropriate density for a parameterless metadata tool.

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

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

Sufficient for a simple read-only tool with no parameters. Without output schema, description adequately indicates a list of 'actions' is returned. Could be improved by noting these are action type identifiers used for filtering, but not required.

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?

Zero parameters with empty schema, meeting baseline expectation. Description adds contextual semantics by clarifying the tool returns 'activity log actions' (metadata) rather than requiring action filters as input.

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

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

Description uses specific verb 'Get' with clear resource 'activity log actions' and scope 'for the account'. The inclusion of 'actions' (vs 'logs') effectively distinguishes this from sibling tool 'pressable_get_account_activity_logs', indicating it returns available action types/categories rather than log entries.

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 implied context that this retrieves action definitions/metadata, but lacks explicit guidance on when to use it (e.g., 'call this first to see valid action types before querying logs') and doesn't mention the sibling relationship or filtering use cases.

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

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

No annotations are provided, yet the description discloses minimal behavioral context. It does not state whether this is read-only, what time range the logs cover, pagination limits, or the format/structure of the returned data. 'Retrieve' implies safety but does not explicitly confirm it.

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

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

The single sentence is appropriately brief but underweight for the tool's complexity. It is front-loaded with the action, but the brevity wastes the opportunity to clarify scope and distinguish from siblings.

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 ambiguous relationship with the sibling actions tool and the undocumented pagination parameters, the description is incomplete. Without an output schema, the description should ideally characterize the log content, which it does not.

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

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

With 0% schema description coverage, the description must compensate but mentions nothing about the page and per_page parameters. No information about default values, maximum limits, or pagination semantics is provided.

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

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

The description states a clear verb (Retrieve) and resource (activity logs for the account), but fails to distinguish from the nearly identical sibling tool pressable_get_account_activity_log_actions. Without clarification on scope differences, agents cannot confidently select between them.

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

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

Provides no guidance on when to use this tool versus the sibling get_account_activity_log_actions, nor any pagination guidance for the page/per_page parameters. No prerequisites or filtering guidance is mentioned.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the operation reads data but doesn't mention if it's read-only safe, whether there are rate limits, authentication requirements, or what the response structure looks like. 'Get a list' is minimally descriptive of the operation's nature.

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 at 9 words with no redundant or wasteful content. The key information is front-loaded ('Get a list'). However, given the lack of annotations and output schema, the extreme brevity means it fails to add contextual value that could have been included within a reasonable length.

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 this is a simple parameter-less read operation, the description is minimally viable. However, it lacks important contextual distinction from the sibling 'pressable_get_available_addons' tool and provides no insight into the response format, making it barely adequate rather than complete.

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

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

The tool has 0 parameters, which per the scoring guidelines establishes a baseline of 4. There are no parameters requiring semantic clarification beyond what the (empty) 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 states a clear verb ('Get') and resource ('add-ons'), with scope clarification ('attached to your account'). This implicitly distinguishes from the sibling tool 'pressable_get_available_addons' by using 'attached' versus 'available', though it doesn't explicitly name the sibling for differentiation.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives, prerequisites, or when NOT to use it. While the purpose is clear enough to imply usage (when you need to see current add-ons), there is no explicit 'when-to-use' guidance.

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

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

No annotations are provided (readOnlyHint, destructiveHint, etc.), so the description must carry the full burden of behavioral disclosure. While 'Retrieve' implies a read-only operation, the description lacks details about caching behavior, rate limiting, authentication scope, or what constitutes the 'account' context (e.g., authenticated user vs. organization).

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

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

The description is a single, efficient sentence with no redundant words. The action verb is front-loaded, and the structure appropriately reflects the simplicity of a zero-parameter getter tool.

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

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

Given the lack of output schema and annotations, the description adequately identifies the return domain (profile and settings) but leaves gaps regarding response structure, pagination (if any), or error conditions. Sufficient for simple tools but incomplete for robust integration.

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 contains zero parameters, establishing a baseline score of 4. The description correctly implies no filtering or input is needed by describing a direct retrieval of account information, aligning with the empty schema.

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

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

The description uses a specific verb ('Retrieve') and identifies the resource ('account profile and settings'). It distinguishes from site-specific siblings (e.g., pressable_get_site) by specifying 'account', but does not explicitly differentiate from other account-level tools like pressable_get_account_addons or pressable_get_account_activity_logs.

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, prerequisites such as authentication requirements, or any conditions where it should not be used. It states only what the tool does, not contextual usage patterns.

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

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

No annotations provided, so description carries full disclosure burden. States 'Get' implying read-only, but lacks critical behavioral details: return format, pagination, caching behavior, or what 'available' specifically means (purchasable vs. enabled). No indication of rate limits or auth requirements.

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

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

Single sentence of appropriate length with no unnecessary words. Front-loaded with the action verb. However, brevity comes at the cost of omitting useful context about return values and sibling differentiation that could fit in a second sentence.

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?

Adequate for a zero-parameter read operation, but gaps remain: lacks output schema description (what fields define an add-on?), misses distinction from pressable_get_account_addons, and provides no behavioral constraints. Acceptable but minimal.

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?

Input schema contains zero parameters. According to evaluation rules, 0 parameters establishes a baseline score of 4. No additional parameter context is needed or provided.

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

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

Description uses specific verb 'Get' and resource 'available account add-ons', clearly indicating a retrieval operation. However, it fails to distinguish from sibling tool 'pressable_get_account_addons', leaving ambiguity about whether this returns currently installed add-ons vs. add-ons available for purchase.

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

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

Provides no guidance on when to use this tool versus alternatives, particularly the similarly named 'pressable_get_account_addons'. No mention of prerequisites, account requirements, or filtering capabilities.

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

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

With no annotations provided, the description carries full disclosure burden but omits critical behavioral details: whether the URL is time-limited/expiring, whether generating the URL triggers audit logs or rate limits, and what data structure is returned (string vs object with URL field).

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

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

The single sentence is front-loaded with the verb and contains no redundant text. However, extreme brevity results in underspecification for a tool with zero schema documentation; an additional sentence explaining parameters or URL expiration would add value without sacrificing clarity.

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 schema coverage, no annotations, and no output schema, the description is incomplete. It omits the temporary/ephemeral nature typical of backup download URLs, the relationship between site_id and backup_id (hierarchical dependency), and the expected return structure.

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 fails to compensate. While 'specific backup' implicitly references backup_id, site_id is completely undocumented. No explanation of parameter formats, valid ranges, or where to obtain valid values (e.g., that backup_id comes from pressable_list_backups).

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 ('Get') and resource ('download URL for a specific backup') clearly stating the tool's function. However, it fails to mention the site-specific context (site_id parameter) or distinguish from sibling pressable_restore_site, which also involves backups but performs restoration rather than providing a download link.

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 provided on when to use this versus alternatives like pressable_list_backups (which must be called first to obtain the backup_id), or prerequisites such as needing an existing backup. The description lacks explicit workflow context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. While 'Get' implies a read-only operation, the description fails to specify error behaviors (e.g., invalid ID), return value structure, or whether this operation is idempotent/safe.

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

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

The single sentence is appropriately sized with no redundant words. It front-loads the action ('Get') and essential qualifiers ('specific', 'by ID') immediately.

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

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

For a simple single-parameter retrieval tool, the description covers the core operation, but given zero schema descriptions, no output schema, and no annotations, it lacks necessary details about the return structure and error states that would make it complete.

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

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

Schema coverage is 0% (the 'id' parameter has no schema description). The description compensates minimally by indicating the parameter is the bookmark ID via 'by ID', but provides no guidance on valid ranges, where to obtain the ID, or the integer format beyond what the schema type declares.

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

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

The description uses a specific verb ('Get') and resource ('Bash command bookmark'), and the phrase 'by ID' clearly distinguishes this singular retrieval operation from sibling tools like 'pressable_list_bash_bookmarks' (plural listing) and 'pressable_create_bash_bookmark' (mutation).

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

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

The phrase 'by ID' implies this tool requires a specific identifier, distinguishing it from list operations, but it does not explicitly state when to choose this over 'list_bash_bookmarks' or mention that the ID must be obtained from a list operation first.

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

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

No annotations are provided, so the description carries the full burden. While 'Get' implies a read-only operation, the description discloses no details about what record types are returned, pagination behavior, rate limits, or whether system records are included.

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

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

Extremely concise at seven words, front-loaded with the verb 'Get'. No wasted words, though the brevity borders on under-specification given the lack of annotations and output schema.

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?

Adequate for a single-parameter tool with complete schema coverage, but has a clear gap: with no output schema provided, the description fails to specify what data structure or record types are returned, leaving the agent blind to the operation's output.

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

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

With 100% schema description coverage for the single `zone_name` parameter, the structured schema already documents the input fully. The description adds no additional semantic details (e.g., format requirements, trailing dot handling) beyond the schema's 'The zone name/domain'.

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

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

States specific verb (Get), resource (DNS records), and scope (for a specific zone). However, it does not explicitly differentiate from sibling `pressable_generate_email_provider_dns_records` or clarify that this retrieves existing records versus generating new ones.

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

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

Provides no guidance on when to use this tool versus alternatives like `pressable_generate_email_provider_dns_records`, nor does it mention prerequisites such as zone ownership or necessary permissions.

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

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

No annotations provided, so description carries full burden. States 'Get the status' implying read-only behavior but does not disclose what the status includes (enabled/disabled state, metrics, etc.), whether the operation is idempotent, or potential error conditions. Minimal behavioral disclosure for a tool with no safety 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?

Single sentence of 9 words. Information-dense with no filler. Appropriately front-loaded with the action and target resource immediately clear.

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

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

Sufficient for a simple single-parameter read operation with complete schema coverage. However, lacks return value description (no output schema exists to compensate), leaving ambiguity about what 'status' encompasses. Adequate but has clear gaps regarding response structure.

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

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

Schema coverage is 100% with the 'id' parameter fully documented as 'Site ID or name'. Description mentions 'for a specific site' which aligns with the schema but adds no additional semantic value (syntax examples, format constraints, identification logic) beyond the schema definition. Baseline score applies.

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

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

Uses specific verb 'Get' and resource 'status of edge caching for a specific site'. Clearly identifies the scope (site-specific) and operation (retrieval). Lacks explicit differentiation from siblings like 'pressable_toggle_edge_cache' or 'pressable_purge_edge_cache', though the verb choice implicitly distinguishes them.

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

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

Provides no guidance on when to use this tool versus alternatives (e.g., when to check status vs. purge cache). No mention of prerequisites, rate limits, or typical use cases.

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

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

No annotations provided, so description carries full burden. While 'Get details' implies a read operation, it omits safety confirmations, permission requirements, rate limits, and what constitutes 'details' in the response.

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 no waste, front-loaded with the action and target. However, extreme brevity leaves critical information gaps.

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?

Inadequate for a tool with 0% schema coverage and no annotations. The description covers only the high-level purpose, failing to document the mandatory ID parameter or behavioral constraints expected for API consumption.

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% (parameter 'id' undocumented) and the description fails to compensate by explaining what the ID represents, its format, or how to obtain it. The word 'specific' weakly implies an identifier is required.

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

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

States the basic operation (Get details) and resource (MU plugin) but lacks scope differentiation from sibling 'pressable_list_mu_plugins'. The phrase 'specific' hints at single-item retrieval but does not explicitly contrast with listing 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?

Provides no guidance on when to use this versus alternatives (e.g., pressable_list_mu_plugins to discover IDs), prerequisites for the ID parameter, or error conditions.

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

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

No annotations provided, so description bears full burden. While 'get' implies read-only, it fails to disclose whether logs are truncated, formatted as text/JSON, or if retrieval is rate-limited. No mention of potential size limits for large logs.

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 no redundancy or filler. Front-loaded with the core action. However, extreme brevity contributes to information gaps.

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?

Lacks output description despite no output schema being present—critical for a log retrieval tool where return format (raw text vs structured entries) is unknown. Single parameter undocumented beyond implied site reference.

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 parameter descriptions. Description mentions 'for a site' hinting that 'id' refers to site ID, but does not explicitly document the parameter name, format (UUID vs numeric), or that it is required.

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

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

States specific verb (get) and resource (PHP error logs) with scope (site). Implicitly distinguishes from sibling pressable_get_account_activity_logs by specifying 'site' vs 'account' context.

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

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

No guidance on when to use versus alternatives (e.g., pressable_get_site for general info), no prerequisites mentioned, and no indication of log freshness or retention limits.

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?

Without annotations, the description carries the full disclosure burden. It successfully communicates that the URL is 'time-limited' (critical security context), but omits expiration duration, permission scope (read-only vs admin), or whether usage is audited. Just meets minimum viable disclosure.

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

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

Extremely efficient single sentence (7 words) with zero redundancy. Key behavioral qualifier ('time-limited') is front-loaded. Appropriate length for a single-parameter read operation.

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 (1 parameter, no output schema) and lack of annotations, the description covers the essential operation. However, for a security-sensitive database access tool, it lacks completeness regarding access scope, session duration, and revocation behavior.

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

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

Schema has 0% description coverage for the required 'id' parameter. The description implies this is a site ID via the phrase 'for a site', but does not compensate for the schema gap by clarifying expected format, where to obtain it, or distinguishing it from other ID types used in sibling tools.

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

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

Specific verb (Get) and resource (phpMyAdmin URL) with a key qualifier (time-limited) that distinguishes it from generic site access tools like pressable_get_site or pressable_get_backup_download_url. Would be 5 if it explicitly confirmed the ID parameter refers to a site ID.

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

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

Provides no guidance on when to use this versus alternatives (e.g., direct database tools), nor mentions prerequisites like site ownership or security considerations. The 'time-limited' phrase implies temporary use but does not elaborate.

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

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

No annotations provided, so description carries full burden. 'Get' implies read-only but doesn't confirm safety, auth requirements, rate limits, or return format. No disclosure of what happens if the site ID is invalid.

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

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

Single sentence, front-loaded with action. Efficient at 9 words, though brevity leaves gaps given the complete lack of annotations and schema descriptions.

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?

Minimum viable for a simple list retrieval with one parameter. Lacks output schema explanation (not required) but given 0% schema coverage and no annotations, should explicitly map the 'id' parameter to 'site_id'.

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 (no description for 'id'), the phrase 'for a specific site' provides critical semantic context implying the 'id' parameter refers to the Site ID. However, it doesn't explicitly confirm 'id = site_id' or describe the expected ID format.

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

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

Clear verb ('Get') and resource ('SFTP users') with scope ('for a specific site'). Distinguishes from sibling 'pressable_reset_sftp_user_password' (list vs reset) and 'pressable_list_wp_users' (SFTP vs WordPress users) implicitly through specific resource naming.

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 guidance on when to use vs alternatives (e.g., when to use this vs 'pressable_reset_sftp_user_password'), no prerequisites mentioned, and no error conditions described.

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

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

With no annotations provided, the description carries full burden of behavioral disclosure. It states 'Get' implying read-only access, but fails to disclose what site details are returned, error handling (e.g., site not found), authentication requirements, or rate limiting considerations.

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

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

Extremely concise at 9 words in a single sentence. Front-loaded with the action verb 'Get'. No redundant or wasted text. Appropriate brevity for a simple lookup operation.

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?

Adequate for a simple CRUD retrieval operation with one parameter. However, given the rich sibling ecosystem (get_site_metrics, get_site_usage, update_site), it lacks context about what 'details' encompass versus those specialized tools. No output schema exists, so description should ideally summarize returned fields.

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

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

With 100% schema coverage, the schema already documents the 'id' parameter accepts 'site ID or site name'. The description mirrors this with 'by ID or name' but adds no additional semantic value such as ID format examples, validation rules, or precedence if both ID and name match different sites.

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 specific verb 'Get' with clear resource 'site' and scope 'specific', implying single entity retrieval. The 'by ID or name' clause distinguishes lookup method. However, it doesn't explicitly differentiate from sibling pressable_list_sites or pressable_get_site_metrics.

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 guidance on when to use this versus pressable_list_sites or other site-related getters. While 'specific site' implies use when targeting one known site, there are no explicit when/not-when clauses or references to 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?

No annotations provided, so description carries full burden. While 'Get' implies read-only safety, it fails to disclose what metrics are returned (CPU, bandwidth, response time?), response format, caching behavior, or rate limits.

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

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

Single sentence is appropriately front-loaded and non-redundant, but given the lack of schema descriptions and annotations, this brevity represents under-specification rather than efficient communication.

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

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

With no output schema, no annotations, and 0% schema parameter coverage, the description should elaborate on return values and parameter details. 'Performance metrics' remains undefined and the ID parameter is not explicitly mentioned.

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% (id parameter undocumented). Description implicitly indicates the id refers to a site ('for a specific site'), but provides no details on ID format, constraints, or whether it accepts slugs vs UUIDs. Minimal compensation for schema deficiency.

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

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

States clear verb ('Get') and resource ('performance metrics') with scope ('for a specific site'). Distinguishes reasonably from siblings like pressable_get_site (general details) and pressable_get_site_usage (usage limits), though could be more explicit about what 'performance' encompasses.

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

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

Provides no guidance on when to use this versus pressable_get_site_usage or pressable_get_site. No mention of prerequisites (site must exist) or timing (real-time vs cached metrics).

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

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

No annotations are provided, placing the full disclosure burden on the description. The text specifies 'storage and resource usage' but does not clarify what resources are included (CPU, bandwidth, disk), whether data is cached or real-time, rate limits, or the return value structure. It confirms the read operation but omits critical 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?

The single sentence is appropriately sized and front-loaded with the operation and resource. However, given the complete lack of schema descriptions and annotations, extreme brevity becomes under-specification rather than efficient communication.

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 resource retrieval tool with no output schema, undocumented parameters, and no annotations, the description must provide sufficient context to interpret results. It fails to explain what constitutes 'usage' data, how it relates to the sibling 'pressable_set_site_usage_limits', or what the caller will receive, leaving significant 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?

With 0% schema description coverage, the description must compensate for the undocumented 'id' parameter. While 'for a specific site' implies the ID refers to a site identifier, it does not explicitly define the parameter as 'site_id', describe acceptable formats (UUID, numeric, slug), or indicate it is the sole identifier required.

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

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

The description states the tool retrieves 'storage and resource usage' using the verb 'Get' and identifies the resource. However, it fails to differentiate from siblings like 'pressable_get_site' (likely general config) or 'pressable_get_site_metrics' (likely performance data), leaving ambiguity about whether this returns current consumption vs. historical statistics.

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 like 'pressable_get_site_metrics' or when retrieving site details via 'pressable_get_site'. It lacks explicit prerequisites, scope limitations, or exclusion criteria.

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?

Without annotations, the description must carry the full burden. It discloses the compound nature of the operation (install AND activate), implying write access. However, it omits critical behavioral details: failure modes if the plugin exists, whether this is idempotent, permission requirements, and 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?

The single sentence is appropriately sized, front-loaded with the action, and contains no redundancy. Every word earns its place.

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

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

For a 2-parameter mutation tool with no annotations or output schema, the description meets minimum viability. However, it lacks necessary completeness for a write operation: no return value description, no error handling disclosure, and incomplete parameter documentation for the 'id' field.

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 50% schema coverage (only 'plugin_slug' is described), the baseline is 3. The description mentions 'on a site,' implying the 'id' parameter refers to a site ID, but provides no format guidance or clarification that this is a Pressable site identifier rather than URL or name.

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 clear verbs ('Install and activate') and identifies the resource ('plugin') and scope ('on a site'). It effectively conveys the dual-action nature of the operation, though it assumes WordPress/Pressable context rather than stating it explicitly.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'pressable_list_plugins', prerequisites for installation, or error conditions (e.g., plugin already installed).

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

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

No annotations provided, so the description carries full burden for behavioral disclosure. It does not specify return format, pagination behavior, filtering capabilities, or whether the operation is read-only (though implied by 'Get'). Missing critical context given zero annotation coverage.

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

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

Single sentence of appropriate length, but offers minimal informational value beyond restating the tool name. Front-loaded but wasteful in that it could have incorporated parameter or behavioral details without sacrificing brevity.

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

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

Given the existence of ambiguous sibling tools and complete lack of parameter schema documentation, the description is insufficient. A complete description should clarify the relationship to `pressable_list_site_backups_by_type` and explicitly document the required site ID parameter.

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% description coverage (the 'id' parameter is undocumented). While the description mentions 'specific site' implying the ID refers to a site identifier, it does not explicitly document the parameter name, type constraints, or expected format (e.g., numeric vs string site ID).

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

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

States a clear verb (Get/List) and resource (backups) with scope (specific site). However, fails to distinguish from the sibling tool `pressable_list_site_backups_by_type`, which creates ambiguity about whether this returns all backups or a subset.

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 provided on when to use this versus `pressable_list_site_backups_by_type` or other backup-related tools like `pressable_create_on_demand_backup`. No prerequisites or exclusion criteria mentioned.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It indicates a read operation via 'Get', but fails to mention pagination behavior, rate limits, or the distinction between this and the singular 'get_bash_bookmark' sibling. The safety profile (read-only) is only implied, not stated.

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 of nine words is appropriately front-loaded and efficient. However, given the gaps in schema coverage and lack of output schema, this brevity results in underspecification rather than effective conciseness.

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

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

Incomplete given the low schema coverage, absence of output schema, and existence of closely related sibling tools. The description should explain the list semantics, mention the search functionality, and clarify the pagination model to be complete.

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

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

Schema coverage is only 33% (only 'search' is described; 'per_page' and 'page' lack descriptions). With low coverage, the description must compensate by explaining pagination, but it mentions no parameters at all, leaving the pagination controls undocumented.

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

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

The description uses specific verb 'Get' and resource 'Bash command bookmarks' with scope 'for your account'. It implicitly distinguishes from sibling 'pressable_get_bash_bookmark' via the word 'list', though it doesn't explicitly clarify when to use this versus the singular fetch variant.

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 provided on when to use this tool versus alternatives, pagination strategies, or search syntax. The description only states what the tool does, not when to invoke it or how to handle the paginated results.

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

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

No annotations provided, so description carries full burden. States 'List' operation but omits pagination behavior, return structure, collaborator field details, and rate limits. Minimal behavioral disclosure beyond basic 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?

Single efficient sentence, front-loaded with action verb. No redundancy or structural waste.

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

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

Adequate for a simple 1-parameter read tool with complete schema coverage. Absence of output schema and annotations creates gaps but is acceptable for this complexity level.

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

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

Schema coverage is 100%, establishing baseline 3. Description adds contextual framing that parameter absence means 'account' scope while presence means 'specific site', adding semantic clarity beyond raw 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?

Clear verb 'List' with resource 'collaborators' and scope 'account or specific site'. Loses a point for failing to explicitly differentiate from sibling tools like pressable_add_collaborator or clarify distinction from user-listing 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?

Implies usage pattern through 'account or specific site' phrasing (use without site_id for account-wide, with it for site-specific), but lacks explicit when-to-use guidance or mention of 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It fails to indicate whether this is read-only (implied but not explicit), doesn't mention pagination behavior, nor error conditions like 'site not found'. For a listing operation with zero annotation coverage, this is insufficient 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?

The single-sentence description is efficiently worded with no redundancy, earning its place. However, given the 0% schema coverage and lack of annotations, it is inappropriately brief—missing parameter documentation that should have been included to achieve minimal viability.

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

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

With no output schema, no annotations, and 0% parameter description coverage, the description should provide comprehensive parameter and behavioral context. It fails to explain the 'id' parameter semantics or disclose return structure, leaving significant gaps the agent must guess at.

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 must compensate for the undocumented 'id' parameter. While the phrase 'for a specific site' implies the ID refers to a site identifier, it does not explicitly state 'The id parameter is the site ID' or describe the expected format (UUID, slug, etc.). Critical semantic information is missing.

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 specific verb 'Get' and clearly identifies the resource as 'cron jobs' scoped to 'a specific site'. This distinguishes it from sibling tools like pressable_list_sites or pressable_list_backups. However, it could strengthen differentiation by explicitly contrasting with other site-specific list 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?

No guidance provided on when to use this versus alternatives, prerequisites (e.g., site existence verification), or when to prefer other cron-related operations (if any existed). The description states what it does but not when an agent should invoke it.

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

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

No annotations provided, so description carries full burden. While 'Get' implies read-only, it lacks disclosure on pagination behavior, rate limits, maximum results, or the scope of 'all' (account-wide vs site-specific). No mention of what properties the zones contain.

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, seven words. Every word earns its place: verb (Get), type (list), scope (all), resource (DNS zones). No boilerplate or redundant text.

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?

Adequate for a zero-parameter list operation, but lacks context on pagination or result limits that would be critical for accounts with many zones. Does not clarify if output includes zone IDs needed for sibling tools like `pressable_create_dns_record`.

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?

Zero parameters present (baseline 4). The word 'all' in the description explains why the schema requires no inputs—implicitly confirming the empty schema is intentional for unfiltered retrieval.

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

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

States specific verb (Get/List) and resource (DNS zones) clearly. Uses 'all' to indicate unfiltered scope. However, it could better distinguish from sibling `pressable_get_dns_records` by explicitly contrasting zones (domains) versus records within zones.

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

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

Provides no guidance on when to use this tool versus alternatives like `pressable_get_dns_records`. Does not mention prerequisites, permissions, or whether this retrieves account-level or site-specific zones.

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

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

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It fails to mention that results are paginated (despite having page/per_page parameters), does not describe the return format, and omits safety characteristics (read-only nature).

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 is appropriately concise, but given the lack of annotations, zero schema coverage, and no output schema, this brevity leaves critical information gaps rather than earning its place through information density.

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

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

With zero annotations, zero schema coverage, no output schema, and multiple sibling tools with similar purposes, the description provides insufficient context. It omits pagination behavior, MU plugin characteristics, and response structure necessary for correct invocation.

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

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

Schema description coverage is 0% (page and per_page are undocumented in schema), yet the description adds no information about these pagination parameters or their expected values. Complete failure to compensate for the schema 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 uses specific verb 'Get' and clearly identifies the resource as 'must-use (MU) plugins', distinguishing it from sibling pressable_list_plugins (regular plugins) by specifying the MU type. However, it fails to clarify the distinction from pressable_get_mu_plugin (singular 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?

Provides no guidance on when to use this tool versus alternatives like pressable_get_mu_plugin or pressable_list_plugins. Does not explain that MU plugins are automatically active WordPress plugins managed at the site level, which would help users determine relevance.

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

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

With no annotations provided, the description carries full burden of behavioral disclosure but provides none. It does not indicate whether the operation is read-only (implied by 'Get' but not explicit), safe to retry, or what happens if the site ID is invalid.

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

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

The single-sentence description is appropriately brief at 9 words, but with zero schema documentation and no output schema, this brevity constitutes under-documentation rather than efficient communication.

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 schema descriptions, no annotations, and no output schema, the description provides insufficient context. It omits: the specific identity of the 'id' parameter, expected return structure, pagination behavior, and relationship to plugin management workflows.

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

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

Schema coverage is 0% and the description fails to adequately compensate. While 'for a specific site' hints that the 'id' parameter refers to a site identifier, it does not explicitly define this mapping or indicate required format/validation rules.

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 ('Get') and resource ('list of plugins') with clear scope ('for a specific site'). However, it fails to explicitly distinguish from sibling tool `pressable_list_mu_plugins` (must-use plugins) or indicate whether these are installed/active plugins.

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 provided on when to use this tool versus alternatives (e.g., `pressable_get_site` to verify site existence first, or `pressable_list_mu_plugins` for must-use plugins), nor prerequisites for obtaining the site ID.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It fails to explain what constitutes a 'security alert' (vulnerabilities, outdated versions, malware), whether data is real-time or cached, or any permission requirements specific to security data.

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

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

The single-sentence description is appropriately sized with zero waste. It is front-loaded with the action verb and efficiently combines resource type, filter scope, and spatial scope ('across all sites') into a compact statement.

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 parameter structure (1 optional parameter, 100% schema coverage, no nested objects) and lack of output schema, the description adequately covers the basic function. However, for a security-related endpoint, it is incomplete—it should describe what constitutes a security alert or link to the vulnerability criteria used.

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

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

Schema coverage is 100% (the 'type' parameter is fully described in the schema), establishing a baseline of 3. The description mentions 'plugins and themes' which aligns with the enum values but adds no additional semantic detail about parameter usage, validation, or defaults beyond what the schema already 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 uses a clear verb ('Get') and specific resource ('security alerts'), and distinguishes itself from sibling tools like 'pressable_list_plugins' by specifying the security context. The scope 'across all sites' adds useful clarification.

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

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

There is no guidance on when to use this tool versus alternatives, or what conditions warrant checking security alerts. The 'across all sites' scope is mentioned but not contrasted with potential site-specific filtering options.

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

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

No annotations provided, so description carries full disclosure burden. While 'Get' implies read-only behavior, the description doesn't confirm safety, mention pagination limits, rate limiting, or what fields are returned in the backup list.

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

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

Single sentence, front-loaded action. Not verbose, but brevity comes at the cost of omitting critical parameter documentation and context. No wasted words, but missing essential content given the 0% schema coverage.

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?

Insufficient for a 2-parameter tool with zero schema descriptions and no annotations. Missing: domain context (site vs account), parameter semantics for 'id', differentiation from similar tools, and behavioral guarantees. Description covers only the type filtering aspect.

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, description must compensate. It successfully explains the 'type' enum values ('filesystem or database'), but completely fails to document the 'id' parameter (likely site ID given tool name), leaving a required parameter semantically undefined.

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

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

States clear verb+resource (Get/list backups) and mentions the type filter. However, fails to mention 'site' context (implied by tool name but not description) and doesn't differentiate from sibling tool 'pressable_list_backups'. The 'id' parameter purpose is left completely ambiguous despite being required.

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

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

Provides no guidance on when to use this versus the sibling 'pressable_list_backups' tool. Does not specify prerequisites (e.g., site ID requirement) or when filtering by type is necessary versus retrieving all 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?

With zero annotations provided, the description carries full responsibility for behavioral disclosure. It fails to indicate this is a safe read-only operation, describe the return format (array of domain objects vs. strings), or mention pagination/empty list handling.

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

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

The single sentence is efficient and front-loaded with the core action. However, given the complete absence of schema descriptions and annotations, extreme brevity becomes a liability rather than a virtue, leaving critical gaps.

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 low-complexity tool (1 flat parameter, no output schema), the description meets minimum viability by identifying the resource and action. However, it inadequately compensates for the 0% schema coverage and lacks context about what constitutes a 'domain' in the Pressable hosting environment.

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 an undocumented 'id' parameter. The phrase 'for a specific site' implicitly signals that the id represents a site identifier, adding minimal semantic value. However, it lacks explicit parameter documentation, format expectations, or examples.

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

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

The description states the tool retrieves domains for a site using the verb 'Get' and resources 'list of domains'/'site'. However, it fails to distinguish from close siblings like 'pressable_add_site_domain' (mutation vs. retrieval) or clarify whether this returns primary/custom domains unlike general site data from 'pressable_get_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?

No guidance provided on when to use this tool versus alternatives. The description does not mention prerequisites (e.g., needing a site ID first) or when domain listing is necessary versus other site operations.

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

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

No annotations provided, so description carries full disclosure burden. Mentions pagination and tag filtering behaviors explicitly, which is helpful. However, fails to clarify safety properties (read-only vs destructive), rate limits, or what the response structure contains.

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

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

Two efficient sentences with zero waste. Front-loaded with primary purpose ('Get a list of sites'), followed by capability modifiers ('filtered by tag name or paginated'). No redundant phrases or tautology.

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?

Appropriately complete for a straightforward list operation with 4 optional parameters and 100% schema coverage. Lacks output description but no output schema exists to require it. Minor gap: could benefit from safety classification given zero 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 has 100% description coverage, establishing baseline 3. Description mentions 'filtered by tag name or paginated' which aligns with parameters but adds no semantic detail beyond schema descriptions (e.g., no guidance on per_page limits or pagination logic).

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

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

Clear verb ('Get') and resource ('list of sites') with scope ('belonging to your account'). However, it fails to explicitly distinguish from sibling 'pressable_get_site' which retrieves a specific site versus this tool which enumerates multiple sites.

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

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

Provides no guidance on when to use this tool versus alternatives like 'pressable_get_site'. Missing prerequisites (e.g., authentication requirements) and exclusion criteria.

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

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

No annotations provided, so description carries full burden. Fails to disclose if this is read-only, what the response format includes (active vs inactive themes, theme attributes), error behavior, or pagination. Minimal safety/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?

Single sentence with no waste. Appropriately front-loaded with the action. However, given the lack of schema descriptions and annotations, extreme brevity harms completeness.

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

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

With zero schema descriptions, no output schema, and no annotations, the description must do heavy lifting. It fails to specify what the 'id' parameter represents (site ID vs other ID) or describe return values, leaving significant gaps in agent understanding.

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 must compensate. The phrase 'for a specific site' implicitly signals that the 'id' parameter refers to the site identifier, adding critical semantic meaning absent from the schema. However, it doesn't explicitly document the parameter or its format.

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

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

States a clear verb ('Get') and resource ('list of themes') with scope ('for a specific site'). Distinguishes from sibling tools like pressable_list_plugins and pressable_list_sites by specifying the correct resource type, though it doesn't explicitly contrast with them.

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

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

Implies when to use (when you need themes for a site) but lacks explicit when-not guidance or alternatives. No mention of prerequisites like needing a valid site ID or how this compares to pressable_get_site.

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

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

No annotations provided, so description carries full disclosure burden. 'List' implies read-only but doesn't confirm safety, rate limits, or return format. Omits critical list behavior: pagination semantics, maximum `per_page` values, or total count availability.

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?

Six words with zero redundancy. However, brevity is excessive given zero schema descriptions—lacks front-loaded parameter hints that would prevent agent hallucination.

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?

Inadequate for a 3-parameter list operation with no output schema and zero parameter descriptions. Missing: pagination behavior explanation, `id` format requirements, and return structure. Should explicitly state this wraps the WordPress REST API users endpoint.

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, description minimally compensates by implying `id` is a site identifier ('for a specific site'). However, completely omits `page` and `per_page` pagination semantics, leaving two-thirds of 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?

States specific verb (List) and resource (WordPress users) with scope (for a specific site). Distinguishes from siblings like `pressable_get_sftp_users` and `pressable_list_collaborators` by specifying 'WordPress users', though could clarify relationship to site collaborators.

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

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

Provides no guidance on when to use versus `pressable_list_collaborators` or `pressable_get_sftp_users`. No mention of prerequisites (site ID requirement) or when pagination is necessary.

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

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

No annotations are provided, and the description adds no behavioral context beyond the action itself. It does not disclose whether the purge is immediate or asynchronous, if it returns status information, rate limits, or whether the operation is idempotent.

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

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

Single sentence, front-loaded with the action verb, and contains no redundant or wasted words. Appropriate length for the tool's complexity.

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

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

Adequate for a single-parameter mutation tool with no output schema, though given the presence of similar cache-related siblings, additional context about edge cache behavior or success indicators would strengthen 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?

With 100% schema description coverage for the single 'id' parameter, the schema already documents the input requirements. The description mentions 'for a specific site' which aligns with the parameter semantics but adds no additional syntactic or format guidance 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 uses a specific verb ('Purge') and resource ('edge cache') with clear scope ('for a specific site'). It implicitly distinguishes from siblings like pressable_flush_object_cache by specifying 'edge' cache, though it does not explicitly contrast these similar 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?

Provides no guidance on when to use this tool versus alternatives like pressable_flush_object_cache or pressable_toggle_edge_cache, nor does it mention prerequisites (e.g., whether edge cache must be enabled first).

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

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

With no annotations provided, the description carries full burden but fails to disclose critical behavioral traits: whether the old password is immediately invalidated, whether a new random password is generated, what the tool returns (likely the new password), or security implications. 'Reset' implies mutation but specifics are absent.

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 of seven words is efficient and front-loaded with the action. No redundancy, though extreme brevity contributes to information gaps in other dimensions.

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 security-sensitive password reset operation with no annotations, no output schema, and 0% parameter documentation, the description is inadequate. It should explain the return value (critical for a reset operation), parameter sources, and side effects, but provides only the basic action statement.

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% (neither site_id nor username have descriptions). The description mentions 'specific SFTP user' which loosely implies the username parameter, but completely fails to explain site_id, expected formats, or where to obtain these values (e.g., from `pressable_get_sftp_users`).

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 (reset), resource (password), and target (specific SFTP user). It distinguishes from sibling `pressable_reset_wp_admin_password` by specifying 'SFTP user'. However, it doesn't clarify what 'reset' means (random generation vs. custom setting).

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

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

Provides no guidance on when to use this tool versus alternatives, prerequisites (e.g., needing to obtain valid site_id/username first), or when-not-use scenarios. No mention of required permissions or verification steps.

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

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

No annotations are provided, so the description carries full burden for behavioral disclosure. It fails to explain what happens during the reset (e.g., generates a temporary password, emails a link, sets a default value) or whether this invalidates existing sessions.

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 no wasted words. However, extreme brevity results in insufficient detail for a security-sensitive mutation operation.

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

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

With no annotations, no output schema, and a single undocumented parameter, the description inadequately covers a sensitive operation. It omits critical security context such as how the new password is delivered or whether the action is logged/irreversible.

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 single 'id' parameter. While the phrase 'for a site' implies the ID refers to a site identifier, the description does not explicitly document the parameter name, expected format, or confirm this mapping, leaving ambiguity between site ID and user ID.

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 states a specific action (Reset) and resource (WordPress admin password for a site), which distinguishes it from sibling pressable_reset_sftp_user_password. However, it lacks specificity on which admin user is affected (primary, all, etc.) and what 'reset' entails.

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 provided on when to use this tool versus alternatives like pressable_run_wp_cli to manually update credentials, or what prerequisites exist (e.g., site ownership verification).

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. While 'restore' implies a write operation, the description fails to clarify whether this is destructive (overwrites current site data), causes downtime, requires specific permissions, or how filesystem_id and database_id relate to backup components.

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

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

The single five-word sentence is efficient but underspecified given the tool's complexity (4 parameters, optional cross-site restoration, destructive operation). It front-loads the action but wastes the opportunity to provide critical context in a compact way.

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

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

For a destructive operation with 4 parameters including optional cross-site targeting capabilities, no output schema, and zero annotations, the description is severely incomplete. It lacks essential context about backup component selection (filesystem vs database) and the implications of the restore_on_site_id parameter.

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

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

Schema description coverage is 50% (filesystem_id and database_id lack descriptions). The description adds no information about these parameters, failing to explain that they likely reference backup IDs obtained from list_backups or list_site_backups_by_type, or that restore_on_site_id enables cross-site cloning.

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 'Restore a site from a backup' provides a clear verb (restore), resource (site), and scope (from backup). However, it misses the nuance that the tool can restore to a different target site (via restore_on_site_id) and doesn't differentiate from sibling tools like pressable_create_on_demand_backup or pressable_get_backup_download_url.

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

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

The description provides no guidance on when to use this tool versus alternatives, prerequisites (e.g., needing backup IDs from list_backups), or warnings that this operation will overwrite existing site data. There is no mention of when restoration is appropriate or required preconditions.

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

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

With no annotations provided, the description carries the full burden of disclosure but fails to mention critical behavioral traits: it does not warn that bash commands can be destructive, does not describe the execution environment (e.g., working directory, user permissions, sandboxing), timeout behavior, or what output format to expect.

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 at six words with the action front-loaded. While efficient, it is arguably under-specified for a high-risk tool, though it contains no wasted words or redundant phrases.

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

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

For a tool enabling arbitrary code execution with no output schema, partial parameter documentation, and no annotations, the description is dangerously incomplete. It lacks necessary safety warnings, execution context, and return value information required for safe and effective invocation.

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

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

Schema coverage is 50% (only `commands` is described in schema as 'List of Bash commands'). The description implies `id` refers to a site ('on a specific site'), providing minimal context for the undocumented parameter, but does not fully compensate for the missing schema documentation by explaining parameter formats, constraints, or providing examples.

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 ('Run') and identifies the resource ('Bash commands' on a 'specific site'), making the basic purpose clear. However, it fails to distinguish from the sibling tool `pressable_run_wp_cli`, which could cause confusion about when to use arbitrary shell commands versus WordPress-specific CLI commands.

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 absolutely no guidance on when to use this tool versus alternatives (like `run_wp_cli`), prerequisites (such as necessary permissions), or warnings about appropriate use cases. For a tool capable of arbitrary command execution, this lack of guardrails is a significant gap.

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

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

No annotations provided, so description carries full burden. Valuably discloses that commands are auto-prefixed with 'wp', preventing user error. However, missing critical safety disclosure: WP-CLI can be destructive (delete content, drop tables), and description doesn't mention output format, permissions required, or execution environment constraints.

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, zero waste. First sentence establishes purpose; second sentence provides essential behavioral constraint (auto-prefixing). Appropriately front-loaded with no filler.

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

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

Command execution tools are high-risk operations with potential for data destruction. Without annotations or output schema, the description should disclose risks, failure modes, or required privileges. Currently insufficient for safe autonomous use given the stakes.

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 50% (id undocumented). Description adds crucial semantic detail not in schema: commands are auto-prefixed with 'wp'. Also implies 'id' refers to a site identifier via 'specific site'. However, 'id' parameter receives no explicit documentation (format, source, example values).

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

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

States specific action (Run WP-CLI commands) and target (specific site). However, fails to differentiate from sibling tool pressable_run_bash_commands, which also executes commands on sites, leaving ambiguity about which to choose.

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

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

Provides no guidance on when to use this versus specialized siblings like pressable_install_plugin or pressable_list_wp_users, nor when to prefer pressable_run_bash_commands. No warnings about command safety or prerequisites.

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

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

No annotations are provided, so the description must carry full burden. It identifies this is a mutation ('Set') but discloses nothing about safety implications, reversibility, what permissions values are valid, or side effects of changing filesystem permissions on a live site.

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

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

Extremely brief at one sentence. While not verbose, it is underspecified rather than efficiently concise. It front-loads the action but lacks supporting details that would earn additional sentences for a security-sensitive filesystem operation.

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

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

For a tool modifying filesystem permissions (a security-critical operation), the description is inadequate given zero schema descriptions and no annotations. It fails to explain what permissions are being set, valid values, the impact on site operation, or expected behavior.

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

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

Schema coverage is 0% - the 'id' parameter has no description. The phrase 'for a site' strongly implies the id refers to a site identifier, which adds minimal context, but it does not document the parameter format, how to obtain it, or that it is required (though schema shows this structurally).

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

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

States a specific verb ('Set') and resource ('PHP file system permissions') and scope ('for a site'). It distinguishes from sibling 'pressable_set_php_version' by focusing on filesystem permissions rather than version configuration. However, 'PHP file system permissions' is slightly ambiguous regarding what specific permissions are being controlled.

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

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

Provides no guidance on when to use this tool versus alternatives, prerequisites (e.g., needing specific privileges), or when not to use it. Siblings like 'pressable_update_site' might also affect site settings, but no differentiation is provided.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure but fails to mention critical mutation traits: whether this causes downtime, requires a server restart, is idempotent, or what happens if an invalid transition is attempted.

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

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

The single sentence is appropriately front-loaded with the action verb, contains zero redundant words, and efficiently conveys the core purpose without wasting tokens.

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 configuration mutation tool with zero schema descriptions, no annotations, and no output schema, the description is insufficient. It omits operational details (downtime warnings, async vs sync behavior) and return value information that would be necessary for safe agent 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?

With 0% schema description coverage, the description partially compensates by implicitly mapping 'PHP version' to the php_version parameter and 'specific site' to the id parameter. However, it does not explicitly confirm that 'id' refers to the site identifier or describe the expected format (UUID, numeric, etc.).

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 ('Set'), the resource ('PHP version'), and the scope ('for a specific site'). It effectively distinguishes from sibling tools like pressable_set_php_filesystem_permissions and pressable_set_site_usage_limits by specifying the exact configuration being modified.

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 (e.g., pressable_update_site), nor does it state prerequisites such as site existence requirements or permissions needed to modify PHP versions.

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

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

No annotations provided, so description carries full burden. States the configuration action but omits critical behavioral details: whether limits are hard caps or soft quotas, what happens when exceeded (data rejection vs warnings), and whether changes are immediately enforced or require propagation.

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 no redundancy and appropriate length. Front-loaded with action and target. However, extreme brevity sacrifices necessary behavioral context for a limits-configuration tool.

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

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

Inadequate for a 4-parameter mutation tool with zero annotations and no output schema. Missing: parameter formats (is id numeric or slug?), side effects of limit enforcement, and return value description.

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 50%. Description adds semantic context for the 'type' parameter ('filesystem or database') and implies 'id' refers to a site, but fails to explicitly document the 'id' parameter or clarify the relationship between 'limit' and 'warning_headroom' values.

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

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

Clear verb 'Set' with specific resources 'filesystem or database usage limits' and scope 'for a site'. Distinguishes from sibling get_site_usage by specifying the write action, though could further differentiate from other configuration tools like set_php_version.

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

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

No guidance on when to use versus alternatives (e.g., get_site_usage to check current consumption), no prerequisites mentioned, and no warning about potential service impact when lowering limits.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It fails to mention whether this is a destructive/reversible operation, whether existing cached content is purged upon disable, or if changes propagate immediately. It only indicates that a state change occurs.

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

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

The single sentence is efficiently front-loaded with the action verbs, contains zero redundancy, and every word earns its place. The brevity is appropriate for a simple toggle operation.

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 annotation coverage, zero schema descriptions, no output schema, and the mutation nature of the tool, the description is insufficiently complete. It lacks critical invocation details (parameter semantics, side effects, return values) necessary for safe use.

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 partially compensates. 'Enable or disable' semantically maps to the `enabled` boolean parameter, and 'for a site' weakly implies the `id` parameter refers to a site identifier. However, it does not explicitly confirm these mappings or document expected ID formats.

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

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

The description provides specific verbs ('Enable or disable'), a specific resource ('edge caching'), and scope ('for a site'). It inherently distinguishes from sibling tools like `pressable_get_edge_cache_status` (read vs. write) and `pressable_purge_edge_cache` (clearing cache vs. toggling the feature).

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 (e.g., when to purge vs. toggle), mentions no prerequisites, and does not warn about potential service interruption or propagation delays.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It fails to explain what defensive mode does, what happens when enabled/disabled, whether changes are immediate, or any side effects on site performance.

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

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

The single sentence is efficient with no redundant words, but its extreme breverity contributes to underspecification given the lack of schema documentation.

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

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

With zero schema descriptions, no annotations, and no output schema, the description provides insufficient context for an AI to understand 'defensive mode' behavior or parameter requirements. Needs elaboration on the feature's purpose and parameter details.

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

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

Schema description coverage is 0%, requiring the description to compensate. While 'for a site' implicitly indicates the 'id' parameter refers to a site ID, the 'enabled' boolean parameter is completely undocumented with no explanation of true vs false semantics.

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

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

The description states the action ('Toggle') and resource ('edge cache defensive mode') but fails to define what 'defensive mode' entails or distinguish this from the sibling 'pressable_toggle_edge_cache' tool. It adds minimal information beyond the tool name itself.

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

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

Provides no guidance on when to use this tool versus alternatives like 'pressable_toggle_edge_cache' or 'pressable_get_edge_cache_status'. No prerequisites, side effects, or conditions for use are mentioned.

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

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

With zero annotations provided, the description carries the full disclosure burden but fails to state what maintenance mode actually does (e.g., shows a maintenance page to visitors), whether changes are immediate, or if the operation is reversible.

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

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

Extremely brief at six words with no structural waste, but the brevity becomes a liability given the lack of supporting documentation in schema or annotations. Single sentence is front-loaded but underspecified.

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 2-parameter boolean toggle with no output schema and zero annotations, the description covers only the bare minimum. Critical gaps remain regarding parameter specifics, maintenance mode behavior, and operational consequences.

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% description coverage, requiring the description to compensate, yet it provides no parameter documentation. It implicitly suggests 'id' is a site identifier via 'for a site', but does not explain that 'enabled' controls the on/off state of maintenance mode.

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

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

States a clear verb (Toggle) + specific resource (maintenance mode) + scope (site). While it doesn't explicitly differentiate from similar siblings like pressable_disable_site, 'maintenance mode' implies a specific WordPress feature distinct from site suspension.

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

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

Provides no guidance on when to use this tool versus alternatives (e.g., disable_site), no mention of prerequisites, and no warnings about impacts on site visitors during maintenance mode.

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

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

No annotations are provided, so the description must carry full behavioral disclosure. It fails to specify whether this is a partial update (omitted fields preserved) or destructive replacement, does not mention side effects, and lacks any mention of success/failure indicators or rate limiting.

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

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

At only six words, the description is under-specified rather than appropriately concise. It fails to meet the richness threshold required for a mutation tool with multiple parameters, lacking front-loaded critical details about scope or behavior.

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

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

For a mutation operation with three parameters and zero annotations or output schema, the description is inadequate. It should clarify the updatable attributes, behavioral side effects, and distinguish its scope from related tools in the sibling list.

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%, requiring the description to compensate by explaining the updatable fields. While it mentions 'settings' generally, it does not enumerate the specific settings available (name, php_version) or explain their expected formats (e.g., PHP version syntax), leaving critical semantic gaps.

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

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

States the basic action (update) and target (site settings) but lacks specificity about which settings can be modified. Fails to differentiate from sibling tools like pressable_set_php_version and pressable_set_site_usage_limits that appear to overlap in functionality.

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

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

Provides no guidance on when to use this general update tool versus the more specific 'set_' prefixed siblings (e.g., pressable_set_php_version). No mention of prerequisites, required permissions, or update semantics (partial vs full replacement).

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