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

Annotations already declare readOnlyHint=false and idempotentHint=true, but the description adds valuable behavioral context: it states that Cloudflare automatically creates the DNS record and certificate, and that external zones are unsupported. This goes beyond annotations without contradicting them, helping the agent understand side effects and prerequisites.

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 redundancy, and the main action is front-loaded. Every clause adds meaningful information—the action, the zone constraint, and the automatic behavior. This is exemplary 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?

Given the schema's high coverage and the presence of annotations (idempotency, non-read-only), the description adds the missing context of zone requirements and automatic DNS/cert provisioning. It doesn't describe the return value, but no output schema exists and the behavior is straightforward. A small gap is that it doesn't mention idempotency for duplicate hostnames, though annotations cover that.

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 parameters with descriptions, so the description is not required to add parameter details. The description itself doesn't elaborate on parameter syntax or relationships beyond what the schema provides, which aligns with the baseline 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 uses a specific verb ('Attach') and resource ('custom domain to a Worker'), clearly distinguishing it from sibling tools like list_worker_domains and delete_worker_domain. It also adds key scope details (zone must be active, auto DNS/cert), so the purpose is unambiguous.

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

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

The description provides a clear prerequisite: the zone must be active in the Cloudflare account, excluding external zones. This gives the agent a condition for when the tool can be used, though it doesn't explicitly contrast with alternatives or state when not to use it. The context is sufficient for choosing this tool over list/delete variants.

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

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

Annotations already indicate a destructive, non-read-only operation, and the description adds valuable behavioral context: the requirement that percentages sum to 100 and the supported traffic-splitting modes (e.g., 90/10). This goes beyond simple purposes to explain how the tool behaves.

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 short sentences that front-load the primary purpose and immediately follow with the essential constraint. Every word serves a purpose, with no redundancy or 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?

For a destructive deployment action with no output schema, the description effectively communicates the immediate impact ('point live traffic') and the critical constraint on percentages. It could mention how to verify success (e.g., via list_deployments), but the core usage context is sufficiently clear given the schema coverage and annotations.

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

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

Schema description coverage is 100%, so the schema fully documents all parameters. The description reinforces the 'percentages sum to 100' constraint but does not add new parameter-level meaning beyond what the schema already provides, earning the baseline score.

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 ('point live traffic at') and clearly identifies the resource (Worker versions), differentiating it from sibling tools like rollback_worker or list_deployments by explaining the core action and its two modes (single version or gradual split).

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 on when to use this tool—to direct traffic to versions—by describing both the single-version and two-version rollout scenarios. It does not explicitly mention alternatives or exclusions, but the usage context is unambiguous.

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

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

The description adds behavioral context beyond the annotations, notably that live traffic is unchanged and that deployment requires a separate step. This is useful non-obvious info for an operation that mutates state (readOnlyHint=false). It doesn't contradict annotations.

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

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

Two sentences, front-loaded with the key caveat, no redundant wording. 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 tool with 9 parameters and no output schema, the description captures the most important contextual nuance (staged, non-deploying). Combined with the rich schema, it is sufficiently complete for an agent to select and use 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 coverage is high (89%) and parameter descriptions in the schema are thorough. The tool description doesn't add param-specific semantics, but given the schema handles it, a baseline 3 is appropriate.

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

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

The description states a specific action ('Upload a new Worker version') on a clear resource, and the crucial qualifier 'WITHOUT deploying it' distinguishes it from create_deployment. The title '(staged)' reinforces the purpose.

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

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

It explicitly names the alternative tool (create_deployment) and explains the relationship ('until the version is referenced by create_deployment'), while advising use for 'staged rollouts'. This gives clear 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?

Annotations already declare destructiveHint=true, so the destructive nature is known. The description adds valuable behavioral context beyond annotations by specifying exactly what gets permanently deleted (versions, deployments, static assets) and the force behavior. This gives the agent a clearer picture of the operation'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?

The description is two sentences, front-loaded with the main action and resource. It packs important details (permanence, scope of deletion, force condition) without any wasted words. 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?

Given the tool's simplicity (2 params, no output schema) and strong annotations, the description fully covers necessary context: what is deleted, when force is needed, and the irreversible nature. There are no significant gaps for an agent to 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 both parameters are already well-documented. The description adds no additional parameter semantics beyond restating the force condition, which is already in the schema. Baseline 3 is appropriate since the schema carries the load.

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 a specific action ('Permanently delete') with a specific resource ('a Worker script') and details its scope ('including its versions, deployments, and any static assets'). This distinguishes it from sibling tools like delete_worker_domain, which deletes only a domain.

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: when you need to permanently delete a Worker and its associated resources. It also explains the force parameter behavior ('to delete even when other resources depend on it'). However, it does not explicitly mention alternatives or when not to use it, so it lacks the full exclusions.

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

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

Annotations already indicate destructive and mutating behavior. The description adds specific context that the action detaches the domain and stops routing to the Worker and its previews, which is more detailed than the annotations alone. It does not contradict the annotations and explains the affected hostname 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?

The description is two concise sentences, front-loading the core action and including a relevant consequence. No unnecessary words or redundancy make it highly efficient.

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

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

Given the simple single-parameter tool, full schema coverage, clear annotations, and no output schema, the description sufficiently covers the action and impact. It explains what happens (detach, stop routing) without needing to detail return values or complex edge cases.

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 only parameter, domain_id, is fully documented in the schema with the source (from list_worker_domains). The description does not add additional parameter meaning beyond that, so with 100% schema coverage, 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 detaches a custom domain from its Worker, using the specific verb 'detach' and the resource 'custom domain'. This distinguishes it from sibling tools like add_worker_domain or delete_worker, which have different actions and targets.

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 by describing the action and its effect ('hostname stops routing'), but it does not explicitly state when to use this tool versus alternatives or provide any exclusions. There is no mention of like 'use this when you want to stop routing' or 'if you need to remove the worker itself, use delete_worker'.

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 goes beyond annotations by disclosing specific behaviors: it uploads only files Cloudflare doesn't already have, applies _headers/_redirects as configuration rather than uploading them, supports .assetsignore rules, and notes that newly created sites are served on workers.dev. This complements the destructiveHint and openWorldHint annotations with concrete operational details.

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 every sentence adds distinct operational detail without redundancy. It is concise yet information-dense.

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 deploy action with no output schema, the description adequately covers input meaning, side effects, and special file handling. It provides enough context for an agent to select and invoke the tool correctly without 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?

Schema coverage is 100%, so the baseline is 3. The description adds extra value by explaining how not_found_handling relates to SPAs and how directory contents like _headers/_redirects and .assetsignore are treated, which is not fully captured 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 clearly states the tool deploys a local directory as a static site (assets-only Worker) on Cloudflare Workers, using a specific verb and resource. It distinguishes itself from sibling tools like deploy_worker or redeploy_assets by emphasizing assets-only and incremental upload 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 provides clear context for when to use this tool (deploying static sites) and includes practical guidance like setting not_found_handling for SPAs. However, it does not explicitly name alternative tools or exclusions, so the guidance is implied rather than direct.

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 annotations already declaring destructiveHint=true and readOnlyHint=false, the description adds valuable context: it explicitly states replacement of code and bindings, and explains the keep_assets option for retaining static assets. It also clarifies the default workers.dev serving behavior, going beyond the annotations without contradicting them.

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 compact four-sentence paragraph that front-loads the core action, then efficiently covers replacement behavior, keep_assets, and default hosting. Every sentence adds meaningful information with no redundancy or fluff.

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

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

Given the tool's complexity (9 parameters, no output schema), the description covers key behavioral aspects: replacement, asset retention, and default workers.dev. It leaves some implementation details (e.g., interaction with versioning) to the schema, but overall it provides sufficient context for an agent to understand the tool's role and important 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?

The schema provides 89% coverage with detailed descriptions for all parameters, so the baseline is 3. The description adds a high-level overview of binding types and the default behavior for workers.dev, but these are already present in the schema. It does not significantly deepen parameter understanding beyond what the schema already offers.

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 ('Upload and deploy a Worker script') and specifies the resource (Worker script with ES modules and bindings). It distinguishes itself from siblings like rollback_worker or list_workers by focusing on deployment and explicitly noting it 'Replaces the Worker's code and binding set if it already exists.'

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 use: deploying or updating a Worker script. It mentions optional bindings, keep_assets for asset retention, and default workers.dev hosting, which imply typical use cases. However, it does not explicitly compare itself to alternatives like create_version or create_deployment, nor does it state when not to use it.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the description doesn't need to restate safety. It adds 'scheduled events' as a clarification, but does not describe potential errors, output format, or behavior when the script does not exist. This aligns with the high-coverage baseline.

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 and resource, zero filler. Every word earns its place. This is an example of 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?

This is a simple getter with one required parameter and no output schema. The description clearly states what it returns (cron triggers/scheduled events). It lacks details on return structure or error scenarios, but the simplicity of the tool means the description is nearly complete. A minor gap is not specifying that the return is likely a list, but the term 'triggers' implies multiple.

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 already provides 100% coverage for the single parameter script_name, described as 'The name of the Worker script'. The description does not add any extra meaning about the parameter, so the schema does the heavy lifting. Baseline 3 is appropriate.

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

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

The description clearly states the verb (Get), the resource (a Worker's cron triggers), and clarifies 'scheduled events' to disambiguate. It distinguishes from sibling tools like set_cron_triggers (which sets triggers) and get_worker (which gets worker details).

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 implicitly indicates when to use: to retrieve the cron triggers for a Worker. It does not mention alternatives or exclusions, but the purpose is clear enough that an agent would know when this tool is appropriate. It lacks explicit 'use X instead' guidance, but the context is unambiguous.

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 read-only and idempotent hints, and the description adds contextual value by noting the version is an 'immutable snapshot' and enumerating the exact fields returned. This goes beyond what annotations provide, though it does not discuss auth or rate limits, which are not critical for a read-only getter.

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 verb 'Get' and immediately specifies the resource and the key details returned. Every clause contributes useful information, with no wasted words or redundancy.

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

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

Given the tool's simplicity, strong annotations, and lack of an output schema, the description fully conveys the scope of information returned by explicitly listing the expected fields (bindings, compatibility date/flags, handlers, usage model). This makes the tool's behavior complete and predictable for an agent.

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 both parameters (script_name and version_id) with clear descriptions, including a helpful note that version_id comes from list_versions. The description itself does not add significant parameter-level detail beyond the schema, so 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 action (Get), the resource (a Worker version's detail), and the specific content returned (bindings, compatibility date/flags, handlers, usage model). It distinguishes itself from sibling tools like list_versions (which lists versions) and get_worker (which gets the Worker itself) by focusing on a specific immutable version snapshot.

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 retrieving details of a specific Worker version, but it does not explicitly state when to use this tool versus alternatives such as list_versions or get_worker. No when-not guidance or alternative tool references are provided, so the usage context is only implied.

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 establish the tool as read-only, idempotent, and non-destructive. The description adds value by specifying exactly what attributes are retrieved, which is helpful for setting expectations. It does not add any additional behavioral caveats (e.g., auth requirements, rate limits), but the annotations cover the safety profile, so a 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, well-structured sentence that front-loads the purpose and enumerates the relevant settings categories without any wasted words.

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

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

For a simple retrieval tool with one parameter and strong annotations, the description adequately explains what is returned. It could be slightly more explicit about what is not included (e.g., code or logs), but this is not necessary given the straightforward scope.

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 already covers the single parameter with a clear description. The tool description does not add additional param semantics beyond reinforcing that it applies to a Worker's settings, but since schema coverage is 100%, no compensation is needed.

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

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

The description clearly states what the tool does with a specific verb ('Get') and enumerates the exact resources: Worker settings (bindings, compatibility date/flags, placement, observability), cron triggers, and workers.dev subdomain status. This distinguishes it from sibling tools like get_worker_code or get_cron_triggers.

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 the tool: whenever you need comprehensive settings for a worker. It clearly defines the scope, but does not explicitly mention alternatives or when-not-to-use cases. However, the context is clear enough for an agent to select it appropriately.

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 annotations already declaring readOnlyHint=true and destructiveHint=false, the safety profile is covered. The description adds valuable behavioral context about how the tool behaves depending on the Worker syntax (one entry per module vs. single script), which goes beyond the annotations. No contradictions found.

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, with two sentences that front-load the core purpose and then add necessary detail about syntax differences. There is no fluff or redundancy.

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

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

Given the tool's simplicity (single parameter, no output schema) and rich annotations, the description covers the key behavioral aspects. It explains what the response will contain based on syntax, which is important for a download tool. Minor gaps like response format details are acceptable given the overall context.

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, as script_name is described as 'The name of the Worker script.' The description does not add any additional parameter-specific semantics, so the schema is sufficient and 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 clearly states the tool's purpose with a specific verb (Download) and resource (Worker's deployed source code). It also distinguishes between module-syntax and service-worker-syntax output, which differentiates it from sibling tools like get_worker that likely return Worker metadata.

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 ('Download a Worker's deployed source code') but does not explicitly mention alternatives or when not to use this tool. It provides context about syntax variations, which helps set expectations, but lacks explicit guidance for choosing this over get_worker or other sibling tools.

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

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

The annotations already declare readOnlyHint=true and idempotentHint=true, establishing that this is a safe, read-only operation. The description adds value by specifying exactly what is verified (API token validity and connectivity), which goes beyond the annotations. 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?

The description is extremely concise, consisting of two short, purposeful sentences. It front-loads the core action and immediately provides a practical use case. There is no redundant or extraneous information.

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

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

Given the tool's simplicity (no parameters, no output schema), the description fully covers all necessary context. It clearly states what the tool does and when to use it, making it complete for an agent to select and invoke correctly. No gaps are apparent.

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 zero parameters, so there is nothing to document in the description. The baseline for zero-parameter tools is 4, as the description need not compensate for missing schema coverage. The description's focus on the tool's purpose 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 uses a specific verb ('Verify') and clearly identifies the resource (API token and Cloudflare connection). This distinguishes it from all sibling tools, which focus on worker management, deployment, and domain operations. The statement is unambiguous and directly conveys the tool's function.

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 ('troubleshooting authentication issues'), which effectively signals the intended scenario. It does not explicitly name alternatives or when-not-to-use, but the unique purpose and sibling context make the usage clear without needing 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 destructiveHint=false. The description adds valuable behavioral context beyond annotations by explaining that deployments map traffic percentages to versions and that the newest deployment is the live one. It also discloses the ordering behavior (newest first), which is useful for interpretation.

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

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

The description is a single, front-loaded sentence that conveys the core action, ordering, and key domain concepts without any wasted words. It is highly concise and well-structured.

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

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

With no output schema, the description explains what the tool returns: deployments with traffic percentages and versions, ordered newest first, and identifies the live deployment. This is sufficient for a simple list tool with good annotations and one parameter, making the description contextually 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 100% with script_name having a clear description ('The name of the Worker script'). The tool description refers to 'a Worker' which implicitly maps to script_name but doesn't add anything beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states the tool lists a Worker's deployments with a specific verb ('List') and resource ('Worker's deployments'). It also adds distinguishing details (newest first, traffic mapping, live deployment) that differentiate it from sibling tools like create_deployment or rollback_worker.

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 about what the tool does and its output ordering, but it doesn't explicitly state when to use it versus alternatives. However, the purpose is unambiguous—listing deployments—so the usage context is clear even without exclusionary language.

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 safety (readOnly, idempotent, non-destructive). The description adds valuable behavioral context: versions are immutable, ordering is newest-first, and the returned fields include deploy message. This goes beyond the annotations without contradicting them.

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

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

The description is two sentences, front-loaded with the primary action and resource, and includes a purposeful alternative. Every word contributes without redundancy.

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

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

For a simple list operation with one parameter and rich annotations, the description provides ordering, content, and a cross-reference to related tooling. No output schema is present, but the description sufficiently indicates expected returns (version ID, number, author, source, deploy message).

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 describes script_name as 'the name of the Worker script.' The description does not add further parameter-level nuance beyond implying that script_name identifies the Worker whose versions are listed. Baseline score is appropriate given 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 clearly states the tool lists a Worker's versions, enumerates the included fields, and specifies ordering (newest first). It distinguishes itself from list_deployments by noting that live versions are a separate concern, preventing confusion among siblings.

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

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

It explicitly directs users to list_deployments for live version information, providing a clear alternative. The assertion that versions are immutable snapshots further clarifies when to use this tool versus deployment-related tools.

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

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

Annotations already declare readOnly, idempotent, openWorld, and non-destructive. The description adds account scoping and optional filters, but does not disclose pagination, response shape, or other behavioral details beyond what annotations and schema imply.

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

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

Two concise, front-loaded sentences. The first states the verb and resource; the second covers filtering options. No filler or redundancy.

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

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

For a simple read-only list tool with comprehensive annotations and complete schema descriptions, the description is mostly sufficient. It lacks explicit output details (e.g., pagination/response format), but the tool's purpose is straightforward and context signals are strong.

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

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

Schema covers all 5 parameters with individual descriptions (100% coverage). The description summarizes the main filter dimensions (Worker name, hostname, zone) but omits 'environment', adding marginal value beyond the schema.

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

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

Clearly states it lists custom domains attached to Workers in the account, using a specific verb and resource. This distinguishes it from sibling add/delete/set domain operations and other worker-related 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 optional filter context (Worker name, hostname, zone) that clarifies when to apply filters. It does not explicitly name alternatives, but the read-only list vs mutate distinction is implicit from sibling names.

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

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

Annotations already declare the tool read-only, idempotent, open-world, and non-destructive. The description adds value by explicitly stating the response includes name, timestamps, and static asset info. No contradictions with annotations.

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

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

The description is two concise sentences, front-loaded with the main verb and object, and adds useful return-detail without any redundant words.

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

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

For a simple list operation with no parameters and no output schema, the description is mostly complete. It names the return fields but could optionally mention pagination or exact data types; however, these are not critical for basic 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?

The tool has zero parameters, so there is nothing to explain. Baseline for zero-parameter tools is 4, and the description does not need to elaborate on parameter 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 clearly states the tool lists all Worker scripts in the account, and mentions the returned fields (name, timestamps, static asset flag). This distinguishes it from sibling tools like get_worker or list_worker_domains, which serve different purposes.

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 a clear context for use: when you need an overview of all Worker scripts. It does not explicitly exclude alternatives or mention sibling tools, but the scope is sufficiently clear from the description itself.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, covering safety. The description adds behavioral context beyond annotations, such as returning 'most recent matching events' and listing the fields included (message, outcome, request, timing). This goes beyond simple read-only disclosure and aligns with annotations, with no contradictions.

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

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

The description is two sentences with no fluff. The first sentence states the primary action and what is returned, the second covers the key prerequisite. Every word adds value, and it is appropriately 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?

For a read-only log query with no output schema, the description adequately explains the tool's purpose, return fields, and the key prerequisite. It does not cover pagination or error handling, but these are not critical given the well-documented parameters and read-only safety annotations. Overall, it provides enough context for an agent to use 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 descriptions cover 100% of the 5 parameters, so the baseline is 3. The description does not add parameter-specific meaning beyond what the schema already provides; it only mentions the observability prerequisite, which is a precondition rather than a parameter semantic.

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 function: 'Query a Worker's logs' with a specific verb and resource. It also distinguishes itself from sibling tools by being the only log-querying tool and by describing what it returns (message, outcome, request, timing). This is unambiguous and specific.

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 usage context by stating the prerequisite that observability must be enabled and explicitly references deploy_worker's enable_observability or update_worker_settings. It does not mention alternative tools or when-not-to-use, but since no sibling tool competes for log access, the guidance is sufficient for selection.

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

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

The description adds significant behavioral context beyond the annotations: it clarifies that the tool creates a deployment that reuses previously uploaded files (keep_assets), avoiding a full re-upload. This directly informs the agent about the tool's side effects (no upload, but a new deployment is created). Annotations already indicate destructiveHint=true, and the description does not contradict this; it complements it by explaining the resource-saving behavior.

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

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

The description is a single, well-structured sentence that front-loads the primary action and immediately explains the key benefit. Every clause earns its place: it states the action, the resource type, the reuse mechanism, and the typical use case. No fluff or redundancy.

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

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

Given the tool's moderate complexity (4 parameters, all documented in schema) and absence of an output schema, the description sufficiently covers the main context: what the tool does, why it exists, and the specific settings it can change. It does not explain return values, but that is not required without an output schema. Slightly more detail on when to prefer this over create_deployment would improve completeness, but it is not necessary.

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 100% parameter descriptions, including enums for html_handling and not_found_handling with detailed explanations. The description adds a high-level mention of these two parameters as the purpose for using the tool, but does not introduce new semantic details beyond the schema. Baseline of 3 is appropriate given full 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 specifies a precise verb ('Create'), a clear resource ('a new deployment of an assets-only Worker'), and a distinctive scope ('reuses its previously uploaded files (keep_assets)'). It also mentions specific adjustable settings (html_handling, not_found_handling), which differentiates it from generic deployment tools like create_deployment or deploy_static_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 a clear use case: 'useful to change html_handling or not_found_handling without re-uploading the site.' This implies when to use the tool, and the reference to 'reuses previously uploaded files' distinguishes it from upload-based tools. However, it does not explicitly name alternatives or state when not to use it, so it falls short of full 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?

The description explicitly discloses that bound resources (KV, R2, D1 data) are NOT reverted, which is critical behavioral information beyond the annotations. It also specifies the 100-version eligibility constraint, adding useful 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 description is two concise sentences that front-load the core action and add one key limitation. It contains no filler and 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?

The tool description covers the main effect, key constraints, and non-reversion of related resources, which is sufficient for a rollback operation with a well-documented schema and annotations. No output schema exists, but the description does not need to detail return values for this type of 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?

All parameters are fully described in the schema, so the baseline is 3. The description reinforces the version_id constraint about the 100 most recent versions but does not add new parameter-level meaning beyond what the schema provides.

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

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

The description clearly states the tool's function with a specific verb ('Roll back') and resource ('Worker') plus the mechanism ('by deploying an older version at 100% traffic'). It also implicitly distinguishes from sibling deployment tools by focusing on the rollback scenario.

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 rolling back to an older version and highlights that only the 100 most recent versions are eligible, which helps with when to use it. However, it does not explicitly mention alternatives or when not to use this tool, so it stops short of a top score.

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

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

The description discloses that this is a full-set replacement (not incremental), the empty-list removal behavior, and the requirement for a scheduled handler. This adds significant context beyond the annotations, which already flag destructive and idempotent behavior. No contradictions with annotations.

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

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

The description is two sentences with zero wasted words. It front-loads the core action ('Replace'), then provides essential caveats and usage patterns. 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 tool with two simple parameters, strong annotations, and no output schema, the description covers all necessary aspects: the replacement semantics, the prerequisite, and the removal pattern. No meaningful gaps remain.

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

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

Schema description coverage is 100%, with both parameters already described in the input schema. The crons parameter description even explains the replacement semantics and empty-list usage. The tool description reinforces this but does not add new parameter-level details, so baseline 3 is appropriate.

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

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

The description uses the specific verb 'Replace' with the resource 'a Worker's full cron trigger set', making the action and scope unambiguous. It clearly distinguishes from sibling tools like get_cron_triggers, which reads rather than writes, and other mutation tools.

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

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

The description clearly indicates when to use this tool: to replace the entire cron trigger set. It adds the prerequisite that the Worker must export a scheduled handler, and explains the empty-list pattern for removing all triggers. It doesn't explicitly mention alternatives or 'when not to use', but the context is clear enough.

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 establish mutating, idempotent, and non-destructive behavior. The description adds the functional behavior of toggling serving and optionally enabling preview URLs, which is useful context. It does not disclose consequences like immediate traffic impact, but the core action is clearly conveyed.

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 primary action and mentions the optional previews feature. Every word earns its place, with no redundancy or 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?

For a simple three-parameter tool with clear annotations, the description covers the main function and the optional previews behavior. It does not explain return values or edge cases, but the tool's simplicity and the schema's completeness make this sufficient.

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

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

The input schema documents all three parameters with descriptions (100% coverage), so the description does not need to add parameter details. The tool description does not go beyond the schema, matching the baseline score 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 uses specific verbs ('Enable or disable') and identifies the exact resource (serving a Worker on its <script_name>.<account>.workers.dev subdomain). It also mentions the optional previews feature, clearly distinguishing it from sibling tools like deploy_worker or rollback_worker.

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 by stating what the tool does, but it does not explicitly say when to use it versus alternatives or mention any exclusions. The context is clear enough for a simple toggle, but there is no direct guidance or reference to related tools.

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

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

Annotations already mark the tool as destructive, but the description adds crucial detail: 'bindings REPLACE the Worker's full binding set'. This goes beyond annotations and warns about a non-obvious destructive side effect. It also clarifies that code is not re-uploaded, which is useful behavioral context.

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

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

Two sentences with no fluff. The first sentence states purpose and scope, the second delivers the most critical warning. Information is front-loaded and every word earns its place.

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

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

Given the tool's complexity (6 params, nested objects) and lack of output schema, the description covers the primary purpose and the most important behavioral caveat. It omits some minor details like return values or whether non-specified settings are preserved, but overall it gives enough context to use the 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 descriptions cover 67% of parameters, and the description adds the key 'REPLACES' semantic for bindings. However, parameters like logpush and compatibility_flags have no schema description and the description does not explain them, leaving some gaps in parameter understanding.

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

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

Description clearly states 'Update a Worker's settings' with a specific list of settings (bindings, compatibility date/flags, logpush, observability) and explicitly distinguishes from code uploads by saying 'without re-uploading its code'. This makes the verb, resource, and scope unambiguous and sets it apart from tools like deploy_worker.

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 is for settings changes without code re-upload, implying use when only settings need modification. However, it does not explicitly name alternative tools or state when not to use it, so it stops short of full when/when-not guidance.

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