HostingFor.AI

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

Annotations already cover the key behavioral traits: readOnlyHint=false, destructiveHint=false, idempotentHint=true. The description adds context about record types and value formats but does not disclose additional behavioral nuances such as duplicate handling, propagation delay, or conflict behavior. With annotations carrying the safety profile, this is adequate but not exceptional.

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

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

Three sentences, front-loaded with the primary purpose and scope, followed by compact format guidance for MX and SRV. No filler or redundant detail; every sentence contributes to correct usage.

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

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

The combination of a 100%-covered schema, an output schema, and annotations covers most operational needs. The description adds situational examples and special value formats. Minor gaps like possible duplicate/conflict behavior or propagation timing are not essential for invoking the tool correctly and are not expected given the richness of the structured data.

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

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

Schema description coverage is 100%, so the schema already documents every parameter in detail. The description adds some reinforcement, especially for MX and SRV value formats, but it mostly repeats what the input schema already states. There is no significant new semantic information beyond the schema.

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

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

The description states a specific verb and resource ('Adds a DNS record to a custom domain') and gives concrete use cases like email provider setup and verification records. It also lists the supported record types, clearly distinguishing this from sibling tools like delete_dns_record and list_dns_records.

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 clear context for when to use the tool, with examples such as setting up email providers or verification records. It does not explicitly name alternatives or state when not to use it, but the examples and record-type list make the intended usage clear.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the agent knows this is a safe read operation. The description adds valuable behavioral context: it fetches a live page, defaults to the home page, and reports DNS-to-hosting status. It does not contradict annotations. It could mention network variability or that the page must be publicly reachable, but the existing disclosure is solid.

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

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

The description is a single, well-structured sentence that front-loads the core action and then lists the reported outputs. Every clause earns its place, and there is no redundant repetition of the title or 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?

Given the output schema exists, the description need not explain return values. The description covers the tool's purpose, default behavior, and key outputs. It could be slightly more explicit about when to prefer this over get_site_info, but overall it is complete enough for an agent to select and invoke it correctly.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description adds meaning by explaining that 'path' defaults to the home page and that 'site' is the domain as shown by list_sites, which helps the agent understand the relationship between the two parameters. This exceeds the baseline 3.

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

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

The description states a specific verb ('Fetches') and resource ('a page from the live website'), and enumerates exactly what is reported: HTTP status, SSL, page title, text preview, and DNS pointing. This clearly distinguishes it from siblings like get_site_info or list_sites, which are about site metadata rather than live page fetching.

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

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

The description implies when to use it: when you need to inspect a live page's HTTP status, SSL, title, preview, or DNS-to-hosting mapping. It does not explicitly name alternatives or exclusions, but the context signals and sibling list make the use case clear. A 4 is appropriate because it gives clear context without explicit when-not-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?

Annotations already mark the tool as mutating, non-destructive, and idempotent. The description adds a genuine behavioral fact not visible in the schema: missing parent folders are created automatically. It stops short of explaining failure modes or existing-folder behavior, but the idempotent annotation covers that concern.

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

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

One sentence, no filler, and the key behavioral nuance (parent folders) is included immediately. 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 two-parameter creation tool with rich annotations and an output schema, the description is nearly sufficient. The only mild gap is not spelling out what happens when the target directory already exists, though the idempotentHint implies a benign repeated call.

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

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

Schema description coverage is 100%, so the schema itself documents path and site meanings with examples. The description adds no parameter-level detail, which is acceptable because the schema carries the full burden.

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

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

The description names a concrete action ('Creates a folder') and a specific resource, and adds recursive-parent behavior. This clearly separates it from siblings like write_file and move_path, which describe different path operations.

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

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

The purpose strongly implies use when a directory is needed, but the description gives no explicit when-to-use guidance, exclusions, or comparisons with sibling tools. An agent must infer the appropriate context from the verb and resource.

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

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

Annotations already mark this as destructive and non-read-only, so the description adds value by requiring user confirmation and emphasizing exact-match inputs. This goes beyond the structured hints and helps an agent handle the operation safely.

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

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

Two sentences, no filler, with the core action and the most important usage constraint front-loaded. Every sentence earns its place.

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

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

For a destructive four-parameter tool with full schema coverage, an output schema, and safety annotations, the description covers the essential operational details: what is deleted, how to identify it, and the need for user confirmation. Nothing critical is missing.

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

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

Schema coverage is 100%, so the schema already documents all four parameters in detail. The description reinforces the 'exactly as list_dns_records shows them' rule and the MX hostname note, but adds little beyond what the schema already states.

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 ('Deletes') and resource ('DNS record from a custom domain'), clearly distinguishing it from sibling tools like add_dns_record and list_dns_records. The title and description align without ambiguity.

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

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

It gives concrete guidance: use exact values as shown by list_dns_records, and confirm with the user first. It does not explicitly name alternatives or exclusion conditions, but the context and sibling list make the intended use clear.

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

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

Annotations already mark destructiveHint=true and readOnlyHint=false. The description adds value by disclosing the permanent nature ('can't be undone') and the recursive deletion of folder contents ('and everything in it'), plus a user-confirmation requirement. These behavioral details go beyond what annotations state.

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 with zero filler. The core action and scope are front-loaded in the first sentence, and the irreversible nature and confirmation requirement are concisely stated in the second. Every word contributes value.

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

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

For a simple delete tool with two well-documented parameters and an output schema, the description is complete. It covers the destructive behavior, the recursive folder deletion, and the need for user confirmation. There are no missing operational details an agent would need to call it correctly.

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

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

The input schema covers 100% of the parameters with detailed descriptions (path relative to root, site domain). The tool description does not add any extra meaning to the parameters beyond what the schema already provides, so it meets the baseline of 3.

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

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

The description clearly states the action ('Permanently deletes'), the resource ('a file, or a folder and everything in it'), and the scope (recursive for folders). This precisely differentiates it from sibling tools like move_path, write_file, and delete_dns_record, which target different operations or resources.

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 clear context that this tool is for deleting files or folders, and includes a caution to confirm with the user first. It does not explicitly name alternatives or when-not-to-use, but the resource scope is obvious, so the context is sufficient without explicit exclusions.

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

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

Annotations already declare readOnlyHint=true, and the description aligns with that. It adds valuable context by noting that row counts and sizes are approximate, which prevents the agent from treating them as precise figures. No behavioral contradictions are 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?

A single, efficiently structured sentence covers scope, primary behavior, conditional behavior, and output specifics without redundancy. The key limitation is front-loaded.

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

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

Given the output schema and read-only annotation, the description is largely complete for invoking the tool correctly. It covers both input modes and notes the approximate nature of table metrics. It could be slightly fuller by explicitly steering agents away from using this tool for executing queries, but that gap is minor.

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

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

The input schema already documents both parameters, so the baseline is 3. The description adds meaning by explaining that supplying the 'table' parameter changes the output from table-level listing to detailed column, index, and CREATE TABLE information, which is not fully evident from the schema alone.

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

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

The description states a specific verb ('lists'), a clear resource ('the site's database'), and the conditional behavior for the optional table parameter. It clearly distinguishes this structural introspection tool from data-manipulation siblings like query_database and execute_sql.

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 communicates when it applies ('PHP + MySQL plans') and the two modes of use. However, it does not explicitly contrast this tool with alternatives such as query_database or execute_sql, so the agent must infer when to choose this over those siblings.

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

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

Annotations already provide destructiveHint=true, but the description adds essential behavioral details beyond that: 'Changes are permanent' and the 30-second execution limit, plus the need to confirm destructive changes. These are operational traits an agent must know and are not present in the schema or annotations.

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

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

The description is three sentences, front-loaded with the core purpose, and packs multiple critical details (permanence, confirmation, placeholders, single-statement constraint, time limit) without redundancy. Every sentence earns its place.

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

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

For a mutation tool with an output schema present, the description covers safety (confirmation), parameter usage (placeholders), execution constraints (one statement, 30s), and explicitly declares the destructive nature. There are no missing pieces an agent would need to call it correctly, and the output schema presumably handles return 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?

The schema has 100% coverage for parameters, so the baseline is 3. The description adds meaning by explaining the '?' placeholder convention and that params must be provided in order, which clarifies how the query and params fields interact. This goes beyond the simple field descriptions.

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

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

The description clearly states the tool runs a single SQL statement that changes the database, with a verb ('runs') and resource ('SQL statement that can change the site's database'). It lists specific operation types (CREATE/ALTER/DROP, INSERT, UPDATE, DELETE) and is distinct from read-only siblings like query_database by emphasizing 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 description gives concrete usage guidance: use ? placeholders with params, one statement per call, and explicitly instructs confirming destructive changes with the user. It doesn't name read-only alternatives directly, but the focus on 'change the database' and the destructive-confirmation rule imply its role versus query_database. A named alternative would make it a 5.

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

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

Annotations already declare readOnlyHint=true, so the agent knows this is a safe read operation. The description adds value by listing the specific details returned, which goes beyond the annotation. It does not mention any other behaviors (e.g., auth requirements, rate limits), but the output schema likely covers return structure. Given the annotation covers safety, a 4 is appropriate.

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 that front-loads the core purpose ('Details for one website') and then lists the specific data points. Every word adds value, and there is no filler. It is concise and efficiently structured.

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

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

With a single required parameter fully described in the schema, an output schema present, and read-only annotations, the description covers all necessary context for an agent to correctly invoke the tool. There are no hidden complexities or missing prerequisites. The description is 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 schema has 100% description coverage for the 'site' parameter, including an example format. The description does not add any additional parameter meaning beyond what the schema provides. Since the schema fully documents the parameter, the baseline of 3 is appropriate.

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

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

The description clearly states the tool returns details for one website, enumerating specific attributes (live URL, plan, file locations, database config location for PHP plans, SSL and nameserver status). This distinguishes it from sibling tools like list_sites (which lists sites) and check_site (which likely checks status). The verb 'get' and resource are explicit.

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

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

The description implies usage for a single website ('Details for one website') but does not explicitly state when to prefer this tool over alternatives like list_sites or check_site. No exclusions or alternative guidance are given, so the agent must infer from context. This is adequate but not explicit.

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

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

Annotations already cover readOnlyHint false, destructiveHint true, and idempotentHint true, so the description need not repeat those. It adds valuable behavioral context: rate/size limits ('Up to 50 URLs per call, 20 MB per file, 100 MB per call'), a warning that 'Signed CDN links expire', and a restriction on file types. This goes beyond the structured metadata without contradicting 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 description is efficient and front-loaded: it states the core purpose first, then the comparison, limits, exclusions, and caveats. Each sentence contributes new information, but it is a dense paragraph that could be slightly better broken out. Still, there is no fluff or repetition.

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

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

For a tool with only 2 parameters a rich schema and an output schema (not shown), the description covers the key non-obvious aspects: limits, file-type restrictions, signed-URL expiration, and legal guidance. It does not explain failure behavior or overwriting, but those are likely handled by the output schema and annotations, so the description is sufficiently complete.

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

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

Schema description coverage is 100%, so both parameters (site and files, including url and path) are already fully documented in the schema. The description adds no new parameter-specific meaning beyond what the schema already states, such as path folder behavior. Baseline 3 is appropriate because the schema carries the weight.

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 begins with a specific verb-resource pair ('Downloads files from public http(s) URLs straight onto the website') and gives concrete examples (Instagram, Wix, Squarespace). It explicitly distinguishes itself from the sibling write_files by claiming to be 'Much faster than downloading and re-uploading them with write_files', making the tool's role clear.

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

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

The description gives direct guidance on when to use this tool vs. write_files, and also states exclusions: 'Only for assets... PHP and server config files can't be imported.' It further advises timing for signed CDN links and legal usage, so an agent knows exactly the conditions under which this tool applies.

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

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

The description adds a meaningful behavioral detail beyond the readOnlyHint annotation: returned record names are relative to the domain, with '@' representing the domain itself. This helps an agent correctly interpret output without guessing. No contradiction with annotations.

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

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

Two short sentences with no wasted words. The main purpose is front-loaded, and the additional naming convention detail earns its place. Excellent 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?

With an output schema presentcars and a fully documented parameter, the description covers the only extra semantics needed for correct invocation (relative names). The tool is simple, and nothing required for calling it correctly is missing.

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

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

Schema coverage is 100% and the single required parameter 'site' is already well-described in the input schema, including examples and a reference to list_sites. The description adds no further parameter-level detail, so the baseline score of 3 is appropriate.

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

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

The description states a specific verb ('Lists') and resource ('DNS records for a custom domain'), which clearly sets it apart from mutating siblings like add_dns_record and delete_dns_record. It does not explicitly name a sibling, but the verb and scope make the purpose unambiguous.

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

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

No guidance is given on when to use this tool versus alternatives such as get_site_info or list_sitesboros. There are no exclusions, but also no contextual cues for an agent to decide this is the right read-only DNS-listing tool beyond the obvious name.

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

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

readOnlyHint already establishes the read-only safety profile, and the description adds useful behavior beyond that: the default website root and the recursion cap of 1000 entries. It does not go into truncation or pagination behavior, but the output schema covers the return shape.

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

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

Two short sentences front-load the primary action and default location, then add the recursive option. There is no filler or unnecessary repetition of structured metadata.

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?

Between the description, fully described schema, readOnlyHint annotation, and output schema, an agent has everything needed to call this tool correctly: default root, path-format example, recursion depth/count cap, and required site parameter. Nothing essential is missing.

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

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

Schema description coverage is 100%, and the schema already documents path, site, and recursive with examples, defaults, and limits. The description mostly restates the default root and recursive behavior, adding little beyond what the schema already provides, so the baseline of 3 applies.

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

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

The description uses a specific verb and resource ('Lists files and folders in a folder of the website') and names the default location, so an agent can tell it apart from sibling list tools like list_sites and list_dns_records. There is no ambiguity about what is being enumerated.

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

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

The description gives practical guidance on the default root and on using recursive for subfolders, so an agent knows how to invoke the tool. However, it does not explicitly state when to prefer this tool over alternatives such as read_file or list_sites, nor provide exclusions.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the agent has safety coverage without the description. The description adds the account-scoped listing scope and output summary fields, but offers no additional behavioral detail such as pagination, ordering, or failure modes – acceptable given the annotations, not rich.

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

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

Two sentences, no filler. The verb and resource lead, the output fields follow, and the workflow hint is compact and useful.

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

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

For a zero-parameter, read-only list tool with an output schema and no hidden side effects, the description covers the needed context: what is listed, the account scoping, and a call-order recommendation. Nothing essential is missing.

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?

There are zero parameters, so the baseline is 4. The description adds no parameter semantics because none are needed; it appropriately focuses on result content.

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 and resource ('Lists the websites this account can manage') and enumerates the returned fields (plan, status, SSL, DNS editing), clearly distinguishing it from per-site tools like get_site_info or list_dns_records.

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?

'Call this first' gives explicit placement in a workflow, and the scope 'this account can manage' tells an agent when it applies. It does not name sibling tools or give exclusion conditions, so it stops short of a 5.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the description does not need to restate that the operation modifies state. However, it adds no extra behavioral context beyond the action, such as the effect on the source path or the overwrite option's consequences. Since annotations cover the destructive nature, a neutral score of 3 is appropriate.

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

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

The description is a single, direct sentence that front-loads the core action. It contains no redundant words or unnecessary detail, making it optimally concise and easy to parse quickly.

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

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

The schema covers parameter semantics and an output schema exists, so return values are not required in the description. However, the description lacks any guidance on when to use this tool or potential edge cases, such as moving directories or overwrite behavior. Given the tool's simplicity and rich schema, a score of 3 reflects that it is adequate but not fully comprehensive.

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 provides comprehensive descriptions for all four parameters, including path syntax and the overwrite flag, achieving 100% coverage. The tool description adds no parameter-specific information beyond what the schema already documents, so it adds no extra value beyond the baseline.

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

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

The description clearly states the tool's action: moving or renaming a file or folder. It specifies both the verb (move/rename) and the resource (file/folder), which distinguishes it from siblings like delete_path or write_file. The title 'Move or rename' reinforces the purpose without ambiguity.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention scenarios like relocating files vs. copying, or when to use delete_path for removal. The description offers no context on prerequisites or comparisons with sibling tools, leaving the agent to infer usage from the name alone.

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

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

Beyond the readOnlyHint annotation, the description adds that the query 'runs in a read-only transaction' and restricts the accepted SQL statement types. These details explain behavioral boundaries that the annotation does not convey, making the tool safe and predictable to invoke.

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 carry the essential information: the operation and allowed statements, then the alternative tool and parameter style. It is front-loaded with the core behavior and contains 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?

Given the output schema already documents return values and the input schema covers max_rows, the description covers all remaining operational context: statement types, read-only guarantee, alternative for writes, and placeholder usage. Nothing needed for correct invocation is missing.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful parameter semantics with its explanation of ? placeholders matched to the params array, which clarifies how to pass values. It does not redundantly restate the schema definitions.

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

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

The description states a specific action ('runs one read-only SQL statement') against a specific resource ('the site's database') and enumerates the permitted statement types (SELECT, SHOW, DESCRIBE, EXPLAIN, WITH ... SELECT). This clearly distinguishes it from siblings like execute_sql, and the title reinforces the read-only nature.

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

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

It explicitly routes to execute_sql for data changes ('use execute_sql to change data'), giving a clear when-not-to-use condition. It also instructs on placeholder usage ('Use ? placeholders with params for values'), which is essential for correct invocation.

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

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

The annotation readOnlyHint=true indicates the operation is read-only, and the description adds useful context by stating the 1 MB limit, UTF-8 decoding for text, and base64 encoding for binary files. This goes beyond what annotations specify.

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

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

The description is concise, two sentences, with no fluff. The key information (size limit, encoding) is front-loaded, making it efficient for an agent to parse.

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

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

Given the output schema exists and covers return types, the description covers the essential behavior (limits and encoding) that an agent needs to predict the output. Missing details like error cases or special file handling are not critical for basic selection.

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

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

The schema descriptions for 'path' and 'site' are detailed, covering relative paths, examples, and the special '~/' prefix. Descriptions add some value by clarifying path resolution and site format, but with 100% schema coverage, the baseline is 3.

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

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

The description clearly states the tool returns file contents with a specific size limit and distinguishes between text and binary formats. It doesn't explicitly differentiate from sibling tools like list_files, but the purpose is clear.

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 tool versus alternatives like list_files or write_file. The description doesn't mention exclusions, such as when not to use it or context for appropriate use.

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

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

The annotations already declare idempotentHint=true, destructiveHint=false, and readOnlyHint=false. The description adds useful behavioral context beyond this by clarifying that the tool triggers a manual SSL request and that issuance is normally automatic, plus a DNS prerequisite. This is valuable but not exhaustive; it doesn't describe possible delays or failure modes, though those may be covered by the output schema.

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

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

The description is two sentences with no filler. The core purpose is front-loaded in the first sentence, and the second sentence adds essential timing context. Every word contributes.

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 low complexity (one well-documented parameter), the rich annotations, and the presence of an output schema, the description fully covers the practical context an agent needs: when to call it, why it exists, and how it relates to automatic issuance.

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

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

Schema description coverage is 100% and the single `site` parameter is already well-described with examples and validation guidance. The description adds general context about the website but no additional parameter-level semantics, so the baseline score of 3 is appropriate.

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

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

The description clearly states the action ('asks for a new free SSL certificate') and the resource ('for the website'). It also differentiates this tool from the sibling set by focusing on SSL certificates rather than DNS, files, or database operations, and from automatic certificate issuance.

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

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

The description gives explicit timing: 'Useful right after the domain's DNS starts pointing here.' It also says when the tool is not needed: 'Certificates are otherwise issued and renewed automatically.' This provides both when-to-use and when-not-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?

Annotations already declare destructiveHint=true and idempotentHint=true, and the description's 'creates or overwrites' is consistent with these. Beyond annotations, it adds useful side-effect context ('folders are created as needed') and a hard constraint ('up to 20 MB'), which help an agent predict the tool's impact.

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 focused sentences that front-load the core purpose and then add behavior and limits. No filler, and each sentence adds necessary information for correct invocation.

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

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

Given the output schema exists and parameters are fully documented, the description only needs to cover operational context. It covers overwrite semantics, folder creation, binary encoding usage, and size limit. It does not mention potential permission/authentication requirements, but these are likely outside the tool's scope and covered by the site 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 100%, so the baseline is 3. The description does not introduce parameter semantics beyond the schema; the mention of base64 for binary files simply echoes the 'encoding' enum description already present in the schema.

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

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

The description explicitly states a specific verb ('Creates or overwrites') and resource ('one file'), which immediately distinguishes it from the plural sibling write_files. It also adds valuable scope details ('folders are created as needed') that clarify the operation's behavior.

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

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

The description gives clear context for when to use the tool: it writes a single file, creates folders as needed, supports binary via base64, and has a 20 MB limit. However, it does not explicitly compare with the sibling write_files (e.g., 'for multiple files use write_files'), so alternatives are only implied by the word 'one file' rather than directly addressed.

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

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

The annotations already mark the tool destructive and idempotent; the description adds 'overwrites' to make the effect concrete and discloses batch limits (100 files, 30 MB) plus the utf8/base64 encoding split. It does not describe partial-failure behavior, but that is not essential given the existing 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?

Two tight sentences front-load the core behavior and limits, then give the use case and per-file parameters. There is no filler or repetition of 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?

With a detailed nested schema, output schema, and annotations for destructiveness and idempotency, the description covers the essential batch operation without needing to explain return values. A brief pointer to write_file for single-file writes would make it fully complete, but the missing piece is minor.

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

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

Schema description coverage is 100%, so the schema fully documents site, path, content, and encoding. The description's mention of path/content/encoding merely summarizes the schema and adds little beyond the aggregate 30 MB limit.

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

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

The description opens with a precise action ('creates or overwrites') and a concrete resource ('up to 100 files'), making the batch nature explicit. The title and second sentence ('publishing a whole website') frame it as the bulk counterpart to the singular write_file sibling, so an agent can tell them apart.

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?

'Ideal for publishing a whole website' gives a clear use context, and the 100-file/30 MB constraint signals when this tool applies. It does not explicitly name write_file as the single-file alternative or list when-not conditions, so it stops short of a full 5.

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