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

No annotations provided, but the description indicates a read-only operation (Get account profile) and lists the data returned. It does not mention any side effects or permissions, but for a simple read operation, this is adequate.

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

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

Two concise sentences: first states purpose, second provides advisory for usage. No wasted words, front-loaded with key information.

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

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

For a simple tool with no parameters and no output schema, the description lists the returned fields and provides context for its use. No further details are 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?

Input schema has zero parameters, so baseline is 4 (as per guidelines). The description does not need to add parameter semantics since there are none.

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 specifies the action ('Get the account profile') and lists the returned fields (name, email, etc.). It distinguishes from the sibling tool 'impreza_topup' by advising to read balance first.

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

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

Explicitly states when to use this tool: before calling 'impreza_topup' to check balance and currency. Provides clear context for its usage.

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

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

With no annotations provided, the description carries the full burden. It only states the basic action of adding a record, omitting behavioral traits like duplicate handling, permissions needed, or whether the operation is idempotent.

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

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

Two sentences, front-loaded with the primary action, no redundant words. Every sentence adds meaningful clarification.

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 complexity (6 params, no output schema, no annotations), the description covers the basic purpose and clarifies two key parameters. However, it lacks information on success/error feedback, duplicate behavior, and how it relates to other DNS tools.

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 baseline is 3. The description adds value by clarifying that 'host' can be '@' for apex, and 'value' is the target (IP, hostname, text), which goes beyond 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 clearly states 'Add a DNS record' specifies the action and resource. It distinguishes from sibling tools like update and delete, making 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?

The description does not provide guidance on when to use this tool versus alternatives (e.g., update or delete), nor does it mention prerequisites or context for 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?

No annotations are present, so the description carries the full burden. It states the tool provisions Tor + publishes the hidden service and persists the .onion address, but does not disclose potential side effects, reversibility, or impact on the existing clearnet route.

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 concise sentences with no waste. Action, use case, and prerequisites are front-loaded and clearly separated.

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 one parameter and no output schema, the description adequately covers purpose, usage context, and prerequisites. It could mention the return value or post-conditions, but overall it 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 coverage is 100% with a description for deployment_id. The tool description adds context by explaining the parameter's role in the action, but the schema already provides sufficient clarity.

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

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

The description uses a specific verb-resource pair ('Add a Tor v3 hidden service') and clearly distinguishes from siblings by focusing on adding an .onion mirror to a clearnet-only deployment. No other sibling tool does this.

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 explicit use case ('customer realized post-install they wanted Tor exposure') and prerequisites for catalog vs custom deployments. No explicit alternatives are mentioned, but the tool is unique among 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?

The description fully discloses the behavioral impact: regenerates Caddy fragment, zero-downtime reload, and fresh Let's Encrypt cert on first hit. It also states what is NOT touched (container/data), compensating for lack of 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?

Four sentences, each adding essential information. The first sentence states the core purpose, and subsequent sentences add technical detail and usage context. No unnecessary 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?

The description covers purpose, usage, behavior, and prerequisites. Without an output schema, it could mention what the tool returns (e.g., success indicator). However, for a simple mutation tool, the description is nearly complete.

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

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

Schema coverage is 100%, but the description adds the important constraint 'Must differ from the current one' for domain and clarifies 'no scheme'. Both parameters are well-described in schema, so description provides marginal extra value.

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

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

The description uses a specific verb ('Re-route') and resource ('RUNNING deployment to a new clearnet hostname'), clearly distinguishing it from sibling tools like deploy or redeploy. It uniquely handles hostname changes without affecting container/data.

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

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

The description explicitly tells when to use (migrate from auto-subdomain to custom domain or rename) and the prerequisite (deployment must be in 'running' status). It provides clear context with no ambiguity.

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

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

No annotations are provided, so the description carries the full burden. It only states the action without disclosing behavioral traits such as reversibility, required permissions, rate limits, or side effects. For a delete operation, this context is important.

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 very concise at 15 words and front-loaded. However, it may be too brief to fully convey necessary context. It could include more detail without becoming verbose.

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 delete operation with 4 required parameters and no output schema, the description is adequate but lacks completeness. It does not mention post-deletion behavior (e.g., propagation time) or any prerequisites, leaving some 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%, and each parameter has a description in the schema. The description adds marginal value by clarifying that type, host, and value together identify the record, which is somewhat helpful but does not significantly extend understanding beyond the schema.

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

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

The description clearly states the action (delete), the resource (DNS record from Impreza-managed domain), and the identification method (type, host, value). It effectively distinguishes from sibling tools like 'impreza_add_dns_record' and 'impreza_update_dns_record'.

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 when a DNS record needs deletion, but it does not explicitly state when to use this tool versus alternatives (e.g., update instead of delete), nor does it provide any exclusions or prerequisites.

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

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

No annotations provided, so description carries full burden. It explains deployment involves target VPS, app name, optional version, domain, onion, and vars. However, it lacks details on idempotency, error behavior, or prerequisites like VPS readiness.

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 main purpose, then guidance. Very concise but packed with information. Slightly dense but 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?

For a deployment tool with 6 params and no output schema, it covers inputs (how to find app names and server IDs), alternative tool, and parameter usage examples. Missing success/error behavior but adequate for agent understanding.

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

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

Schema coverage is 100%. Description adds examples for 'vars' (e.g., signups_allowed for Vaultwarden) and explains domain/onion relationship: 'Omit + set onion:true for onion-only.' This goes beyond schema descriptions.

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

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

The description states 'Install an app from the Impreza catalog... on a target VPS', clearly specifying verb, resource, and target. It distinguishes from the sibling 'impreza_deploy_custom' by noting that tool is for non-catalog apps.

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

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

Explicitly directs to use 'impreza_list_apps' for app names and 'impreza_list_servers' for agent_id. Provides clear alternative: 'impreza_deploy_custom' for non-catalog apps.

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

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

With no annotations provided, the description carries full burden. It explains the deployment process (e.g., tars + uploads local dir, returns public key for deploy_key) and covers modes. However, it does not mention whether deployments with duplicate names are overwritten or what happens on failure, so not fully comprehensive.

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 well-structured with bulleted modes, front-loaded with the main action, and uses list formatting for clarity. Every sentence adds essential information, avoiding fluff despite the complexity.

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

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

Given 17 parameters, 3 required, and no output schema, the description covers modes, parameter dependencies, and references other tools. It could be improved by mentioning the return value (e.g., deployment details) and handling edge cases like duplicate names, but overall it is quite 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?

Although schema coverage is 100% (each parameter has a description), the tool description adds significant value by grouping parameters by mode, clarifying relationships (e.g., dir vs git_url for dockerfile mode), and explaining how auth methods work (deploy_key vs pat). It goes beyond the schema.

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

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

The description clearly states it deploys a custom app to an Impreza VPS, lists three distinct modes, and differentiates from sibling tools like impreza_deploy_catalog_app by explicitly mentioning 'custom (non-catalog) app'.

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 explains when to use each mode (e.g., 'public Docker image URL' for image mode, 'build from a Dockerfile' for dockerfile mode), provides prerequisites (agent_id from impreza_list_servers), and gives explicit guidance like 'when the customer says "deploy this" with a project open, Dockerfile mode is the right choice.'

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 states 'Read-only', which is critical given no annotations. It conveys that the tool performs a safe query without side effects. However, it could mention that it doesn't modify any resources or affect domain registration.

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, front-loading the purpose and then providing usage details. Every sentence serves a purpose 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?

The description covers the basic function and input format, but it lacks information about the output or return values. For a checking tool, an agent would benefit from knowing what the response contains (e.g., boolean availability, price). No output schema is provided, so the description should compensate.

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 describes the 'domain' parameter with examples, achieving 100% coverage. The description adds only minor clarification about comma-separated domains. Since schema coverage is high, the description adds limited 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?

The description clearly states the tool checks domain availability and price, using the verb 'Check' and specifying the resource. It distinguishes from siblings like 'impreza_domain_details' by focusing on pre-registration checks.

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

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

The phrase 'before registering' provides clear context for when to use this tool. While it doesn't explicitly mention when not to use it or list alternatives, the context is sufficient for an agent to choose it over other domain 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?

With no annotations, the description carries full burden. It explicitly states 'Read-only' and enumerates returned fields, providing clear behavioral context beyond the verb 'get'. However, it does not disclose potential side effects (none expected) or error conditions.

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 plus 'Read-only.' – extremely concise with no wasted words. Key information is front-loaded.

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

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

Given the tool's simplicity (one parameter, no output schema), the description is fairly complete. It lists the returned fields. It could optionally mention that the domain must be managed by the account, but this is implied by 'registered domain'.

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% (domain parameter described as 'The domain name, e.g. example.com.'). The tool description adds no additional meaning beyond the schema, so a baseline score 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 'Get a registered domain's details' and lists specific fields (status, dates, nameservers, etc.), making the purpose unmistakable. It distinguishes from siblings like impreza_domain_check (which likely checks availability) and impreza_change_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 implies usage for read-only inspection but does not explicitly state when to use this tool versus alternatives like impreza_domain_check or impreza_set_nameservers. No exclusionary guidance is provided.

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

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

No annotations provided, so description carries full burden. It discloses synchronous behavior, timeout (~25 seconds), and importantly a security warning about unsanitized logs and instructions to not act on log contents. This far exceeds minimum transparency.

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

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

Description is relatively long but every sentence adds value: purpose, behavior, use cases, security. Could be slightly tightened, but no waste.

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

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

No output schema, so description explains return is log text and behavior. Covers how it works and security handling. Adequate for the tool's complexity.

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

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

Schema coverage is 100%, so baseline is 3. Description does not add parameter-specific semantics beyond what schema provides, but behavioral context (synchronous, enqueue) is given.

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

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

Description states 'Fetch the last N lines of container logs for a deployment.' It uses a specific verb (fetch) and resource (container logs), and clearly distinguishes from siblings which handle deployments, DNS, account info, etc.

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

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

Description provides specific use cases: 'debug a failed deploy' or 'inspect a running app's output.' It does not explicitly exclude other scenarios or name alternatives, 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?

No annotations provided, so the description carries full burden. Discloses key behaviors: token is discarded after use ('never stored'), refusal if already connected, and for manual mode the response returns a one-time webhook token. Also specifies the exact conditions for success (custom deployment with specific attributes).

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 longer than ideal but every sentence contributes meaningful information. It is well-structured with clear sections for the two modes, prerequisites, and error conditions. A minor reduction in verbosity might improve conciseness, but the current structure is highly effective.

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 complexity of two modes, provider-specific instructions, prerequisites, and error handling, the description is remarkably complete. It covers what the tool does, how to use each mode, what to expect from the response, and when to use an alternative tool. No output schema exists, so the description compensates by detailing the response content.

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% (both parameters have descriptions), but the description adds significant value: explains the optional github_pat for GitHub one-click flow, provides a link for PAT generation, and clarifies that omitting it triggers the manual/generic flow. Also reiterates the deployment_id requirement with specific format and constraints.

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: 'Wire up auto-deploy: connect a push webhook so every push to the deployment's tracked branch triggers a redeploy.' It specifies the verb (connect) and resource (deployment's webhook), and distinguishes from siblings like impreza_git_webhook_disconnect and impreza_git_webhook_status.

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

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

Provides explicit when-to-use guidance: 'Works with ANY provider against one per-deployment secret.' Elaborates on two modes (GitHub one-click vs manual/generic) with clear prerequisites: 'Only works on custom deployments created with mode=dockerfile and a git_url source. Refuses if already connected (call disconnect first to re-wire).' This includes when-not-to-use and mentions the alternative tool (impreza_git_webhook_disconnect).

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

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

No annotations provided, but description discloses all behavioral traits: always clears Impreza state, rejects further pushes, idempotent.

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

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

Single paragraph, front-loaded main action, followed by details and parameter guidance. No redundant information.

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

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

For a tool with 2 params, no output schema, and no annotations, the description covers behavior, idempotency, and usage completely.

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%, but description adds context: explains 'github_pat' role and 'deployment_id' scope, going beyond schema.

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

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

Describes specific verb 'Stop auto-deploying from git' and resource 'webhook state'. Distinguishes from sibling tools like connect and status.

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

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

Explicitly states when to supply 'github_pat' (GitHub) vs. manual removal (other providers), and notes idempotency.

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

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

No annotations provided, so description fully carries burden. It lists return fields (git url, branch, mode, webhook active, payload URL) and notes prerequisites (deployment must have git source). No side effects implied; safe read.

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 primary purpose, followed by return fields and usage context. No wasted words.

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

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

Single parameter, no output schema, but description fully covers what the tool returns and when to use. No missing information for an inspection tool.

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

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

Schema description coverage is 100% with parameter description already in schema. Description adds minimal context (dpl_... id of custom deployment). 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?

Description clearly states the tool checks if a custom deployment is wired for git-push auto-deploy, specifying verb and resource. Distinguishes from sibling tools like impreza_git_webhook_connect by being a status check.

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

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

Explicitly advises to use before calling impreza_git_webhook_connect and clarifies which deployment modes are incompatible (image-mode, manifest-mode). Provides clear 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?

No annotations are provided, so the description carries the full burden. It describes the listing behavior but does not mention authentication requirements, rate limits, or the return format. For a simple read-only list tool, this is adequate but lacks depth.

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-loads the core purpose, and wastes no words. The distinction from the sibling tool is efficiently integrated.

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 should explain what the return value contains (e.g., app objects with fields like name, category, tags). It does not mention pagination or limits, leaving the agent without critical information for handling results.

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

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

Schema coverage is 100% and the description only restates the filter options without adding new meaning. It does not explain how the filters combine or provide examples beyond what the schema already defines.

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 apps from the Impreza curated catalog, provides examples (Vaultwarden, n8n, Nextcloud), and distinguishes it from the sibling tool impreza_deploy_custom for non-catalog apps.

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

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

The description explicitly tells when to use this tool (for catalog apps) and when to use impreza_deploy_custom instead (for custom apps), providing clear decision context.

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

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

With no annotations, the description carries full burden. It implies a safe read operation by stating 'list' and 'currently-installed,' and notes optional filters. No destructive claims or hidden behaviors are omitted.

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

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

Two sentences, each adding value. The first states the core purpose, the second provides usage guidance. No unnecessary words 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?

Given no output schema and two simple params, the description is adequately complete. It covers purpose, filters, and intended use cases. Minor lack of pagination info is acceptable for a listing tool.

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

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

Schema coverage is 100% with descriptions for both parameters. The description adds marginal value by restating the agent_id filter. For status, it lists example values but doesn't provide additional semantics beyond the schema.

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

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

The description clearly states the tool lists 'currently-installed app deployments' and distinguishes it from sibling tools like 'impreza_deploy_catalog_app' and 'impreza_uninstall_deployment' by mentioning use cases involving deployment_id and state confirmation.

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 explicit usage context: 'to confirm what's running before adding more, or to find a deployment_id to uninstall/restart.' However, it does not directly contrast with alternative tools like 'impreza_list_apps' or 'impreza_list_services' for different scopes.

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 labels the tool as 'Read-only,' which is good given no annotations, but lacks details on authentication, behavior for non-existent domains, or rate limits.

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

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

A single sentence, no wasted words; front-loaded with the action and key information.

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

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

Adequate for a simple list tool with one parameter and no output schema. Could mention potential errors or pagination, but not essential.

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 describes the 'domain' parameter. The description adds value by enumerating the returned fields (host, type, value, TTL, priority).

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 DNS records (with specific fields) for a domain, which is distinct from sibling tools like impreza_add_dns_record or impreza_delete_dns_record.

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 implies this is the read-only alternative to add/delete/update DNS records, but does not explicitly state when to use or provide exclusions. The context from sibling names helps.

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

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

No annotations provided, so description carries the full burden. It implies a read-only listing operation but does not explicitly state safety or side effects. The return fields are disclosed, which is adequate but not highly transparent.

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 succinct sentences with no redundant information. The first defines scope, the second adds usage guidance and return data.

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 no output schema, the description compensates by listing return fields and usage context. Lacks details on ordering or pagination, but these are not critical for a parameterless list tool.

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

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

No parameters exist in the schema (100% coverage). Baseline for 0 parameters is 4, and the description adds value by explaining the output and usage context.

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

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

The description clearly states it lists every Impreza-managed VPS and bring-your-own servers, and specifies the returned fields (hostname, IP, status). This distinguishes it from siblings like impreza_vps_status which focuses on a single server.

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

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

Explicitly instructs to use this tool before calling impreza_deploy_custom to find the correct agent_id. Provides clear context but does not explicitly mention 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?

No annotations provided. Description implies a read operation (listing) with no destructive effects. Could mention pagination or rate limits but adequate for a simple list.

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

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

Two sentences: first states purpose and output, second gives usage context and optional parameter. No wasted words, 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 simple list tool with one optional parameter and no output schema, description covers all necessary info: purpose, returned fields, usage motivation, and filter hint.

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 100% of parameters with description. Description adds examples of status values (Active, Suspended, Terminated) and reinforces that filter is optional, adding value beyond schema.

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

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

Clearly states it lists billable services with specific fields (service id, product name, status, billing cycle, next due date) and explicitly connects to impreza_vps_* tools, distinguishing from sibling tools like impreza_list_apps.

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

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

Explicitly says to use this tool to find service_id for VPS tools and mentions optional status filter. Lacks explicit when-not-to-use or alternatives, but 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?

No annotations provided, but the description covers key behaviors: near-zero downtime, source unchanged, vars merge, system vars preserved, returns 'updating' state. Could mention failure implications or auth requirements.

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

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

Three sentences, front-loaded with primary action. Slightly verbose but still efficient and well-structured.

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

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

Given no annotations or output schema, the description adequately explains purpose, behavior, parameter context, and return indicator. Could note failure handling or prerequisites for completeness.

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

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

Schema coverage 100% with descriptions. The description adds meaning by explaining 'vars' effect (merged, system vars preserved) and deployment_id format (dpl_...), going beyond schema.

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

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

The description clearly states the tool does an in-place rebuild of a custom deployment, reusing the same deployment and preserving domain/URL. It distinguishes from uninstall+recreate by explicitly preferring this tool for shipping new builds.

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

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

The description explicitly says 'PREFER it over uninstall + recreate' and explains when to recreate instead (to change image ref or git URL), providing clear guidance on tool 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?

With no annotations provided, the description fully covers behavioral traits: non-destructive, data volumes preserved, status flips to 'installing' then back to 'running'. It does not mention permissions or edge cases, but for a restart operation it is adequately transparent.

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 concise sentences, each adding value: first sentence states core action and non-destructive nature, second adds process details and status behavior, third specifies scope. No wasted words.

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

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

Given the tool's simplicity (1 param, no output schema), the description covers action, safety guarantees, status changes, and applicability. It does not mention error conditions or prerequisites, but overall provides sufficient context 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?

Schema coverage is 100% with one parameter described as 'The dpl_... id to restart.' The description adds no additional parameter-specific meaning beyond the schema, meeting 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 (restart), the resource (deployment's docker-compose stack), and specifies it is non-destructive, distinguishing it from siblings like impreza_redeploy_deployment or impreza_uninstall_deployment. It also notes it works for both catalog and custom deployments.

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 (non-destructive restart with data preserved) but does not explicitly state when not to use or mention alternatives. However, it is clear enough that an agent can infer the appropriate context.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It indicates that the operation is a replacement ('replace'), which implies mutation and overwrites existing nameservers. However, it does not disclose crucial behavioral traits such as authorization requirements, propagation delays, reversibility, or side effects like potential downtime. The disclosure is adequate but minimal.

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 of 13 words, front-loading the main action and constraint. Every part is essential, with no redundant or vague phrasing. It efficiently communicates the tool's core purpose.

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

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

The tool is a simple operation with 2 parameters and no output schema. The description covers the basic purpose and parameter constraint. However, it lacks details about expected outcomes (e.g., success response, propagation time), prerequisites (e.g., domain ownership, authorization), and edge cases. Given the absence of annotations, more context is needed for full completeness.

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

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

Schema description coverage is 100%, with both parameters described. The description adds no new information about parameters beyond the schema; it only reinforces the 2–4 hostname constraint already present in the schema. According to the rules, with high schema coverage the baseline is 3, and the description does not significantly enhance 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?

The description clearly states the verb 'Replace' and the resource 'authoritative nameservers for a domain'. It specifies the number of hostnames (2–4) and the use case (point to Impreza DNS or external). This distinguishes it from sibling tools like impreza_add_dns_record, which handle individual DNS records within 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 explicitly states when to use this tool: to point a domain at Impreza DNS or an external provider. It implies the context of changing nameservers, which is distinct from other DNS-related siblings. However, it does not provide explicit exclusions or mention alternatives among the sibling list.

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

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

The description explicitly states the return values (invoice_id, amount, payment_url) and the auto-credit behavior. It also notes no-KYC and privacy-first. However, it omits details like required authentication or potential side effects, but overall provides good transparency.

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

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

The description is three sentences, each serving a purpose: defining the action, listing return values, and directing to poll for status. It is front-loaded and concise with no superfluous content.

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 top-up creation tool, the description covers the main purpose, return values, and post-use polling. It lacks details on error handling or idempotency, but is sufficient for correct invocation.

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

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

The input schema has 100% coverage, but the description adds value by specifying the amount range (1.00–10000.00) and explaining that the method parameter is optional and allows switching on the payment page, enhancing understanding beyond the schema.

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

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

The description clearly states the verb 'Create' and the resource 'account-balance top-up invoice payable in crypto', listing specific cryptocurrencies. It distinguishes from the sibling tool 'impreza_topup_status' which is for polling state.

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 tells when to use (to top up account balance with crypto) and provides follow-up action (poll impreza_topup_status). It does not explicitly state when not to use or compare with alternatives, but the context is clear.

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

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

No annotations are provided, so the description carries the full burden. It transparently describes the return values (address, amount, URI) and gives a security warning about verifying details. It implies a non-destructive read operation, which is sufficient for an agent to understand 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?

The description is concise, fitting into a single paragraph without wasted words. It front-loads the main purpose and then branches into variants and security notes. While it could be broken into shorter sentences, it remains clear and efficient.

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

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

Given the tool's moderate complexity (2 parameters, no output schema), the description provides sufficient context: the prerequisite call, parameter behavior, return components, and a security advisory. It is complete enough for an agent to use the tool 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 already has 100% coverage of parameters with descriptions. The description adds value by explaining that omitting 'crypto' lists options and that 'invoice_id' comes from a specific prior call, which enhances semantic understanding beyond the schema.

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

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

The description clearly states the tool's purpose: getting crypto payment details for a top-up invoice. It specifies the outputs (address, amount, URI) and distinguishes between calling with and without the 'crypto' parameter, which sets it apart from potentially similar tools.

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

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

The description provides explicit usage guidance: call 'impreza_topup' first for invoice_id, then this tool. It explains the behavior for both cases of the 'crypto' parameter and includes security instructions for verification. It does not explicitly state when not to use this tool, but the context is clear.

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

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

No annotations are provided, so the description must carry the behavioral burden. It discloses return fields (status, amount, balance) and the polling nature, but does not explicitly state idempotency, rate limits, or that it is read-only. This is adequate but not comprehensive.

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 action (poll) and result. No unnecessary 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 polling tool with one parameter and no output schema, the description covers key return fields. It could mention polling intervals or status values explicitly, but it is largely 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 single parameter invoice_id is fully described in the schema (100% coverage). The description adds no further semantics beyond referencing impreza_topup. Baseline score 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 polls a top-up invoice and returns status, amount, and balance. It specifies the output fields and links to the sibling tool impreza_topup, distinguishing its purpose.

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

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

The description implies usage after impreza_topup to check payment status. It does not explicitly exclude alternatives like impreza_topup_payment, but the context is clear. A score of 4 reflects good clarity without formal exclusion 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?

With no annotations, the description discloses key behavioral traits: it is idempotent and optionally destructive via `purge_data`. It does not mention prerequisites or error states, but given the tool's straightforward nature, this is sufficient.

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. Every sentence adds value—action, key parameter, idempotency—without 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?

For a simple tool with two parameters and no output schema, the description covers all necessary information: purpose, required parameter, optional flag, idempotency. An agent has enough to invoke 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 100%, so the descriptions in the schema already explain both parameters. The tool description adds minimal extra context (e.g., 'catalog or custom' for deployment_id). It does not significantly enhance understanding beyond the schema, earning a 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 clearly states the action ('Uninstall a deployment (catalog or custom)') and the identifier ('by `deployment_id`'). It distinguishes this tool from sibling tools like redeploy or restart by focusing on removal. The idempotency note further clarifies 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 explicitly states when to use the tool (to uninstall deployments) and the optional `purge_data` flag. It does not explicitly mention when not to use it or alternatives, but idempotency ensures safe repeated calls. It is clear enough for correct 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?

No annotations are provided, so the description must disclose behavioral traits. It fails to mention whether the update is destructive (e.g., overwrites existing values), idempotent, or has side effects. It also omits details like case sensitivity, validation rules, or error behaviors on missing records.

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

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

The description is extremely concise: two sentences, front-loaded with the core action, and no redundant words. Every part is necessary 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?

While the description explains the update mechanism, it lacks several key details: no mention of output (return value or success/failure indication), no disclosure about partial updates (e.g., can you update only value while keeping TTL?), and no links to prerequisites or domain management context. Given the tool has 7 parameters (5 required) and no annotations, a more complete description would include behavioral consequences and result format.

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?

Since schema_description_coverage is 100%, the baseline is 3. The description adds value by explaining the identification logic (locate by type+host+old_value) and the role of new_value, which goes beyond the schema. However, it does not elaborate on optional parameters like ttl or priority beyond their schema descriptions.

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

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

The description clearly states the verb ('Update'), the specific resource ('DNS record on an Impreza-managed domain'), and the identification method (by `type` + `host` + `old_value`). This distinguishes it from sibling tools like `impreza_add_dns_record` and `impreza_delete_dns_record`, 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 does not provide explicit guidance on when to use this tool over alternatives, such as when to add vs. update vs. delete a record. It only states the operation's mechanics, leaving the AI agent to infer appropriate usage context.

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

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

No annotations provided, so the description must cover behavior. It reveals the async nature by instructing polling, but omits side effects, permissions, or limits on concurrent backups.

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

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

Two sentences, zero waste. Front-loaded with the core action, followed by a critical next step. 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 its simplicity (one param, no output schema), the description covers the essential action and polling guidance. Minor missing context: concurrent backup handling or typical duration.

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

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

Schema coverage is 100% with a clear parameter description. The tool description adds no extra value to the parameter beyond what the schema already provides.

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

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

The description explicitly states the action ('Trigger an on-demand backup') and the resource ('Proxmox VPS'), distinguishing it from sibling tools like power or list_backups.

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 to poll for completion using a sibling tool, but does not specify when to use this tool versus alternatives (e.g., scheduled backups) or exclusions.

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

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

No annotations are provided, so the description carries the burden. It states read-only behavior, which is helpful, but lacks details on error cases, empty results, or authentication requirements.

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

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

The description is a single sentence plus 'Read-only.', no unnecessary words. Essential information is front-loaded.

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

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

For a simple list tool with one parameter and no output schema, the description adequately covers functionality, input source, and return fields. Minor omission: no mention of pagination or limit, but not critical.

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 parameter service_id is already described in the schema (100% coverage). The description adds value by specifying it is numeric and referencing impreza_list_services, providing context beyond the schema.

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

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

The description clearly states the tool lists backups for a Proxmox VPS, specifying fields (id, timestamp, size) and marks as read-only. It distinguishes from sibling tools like impreza_vps_create_backup.

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

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

Description implies usage with a service_id from impreza_list_services, but does not explicitly state when to use vs alternatives or provide exclusion criteria.

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

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

Declares read-only operation and describes output (template_id + label). With no annotations, the description carries the burden; it adequately conveys safety and purpose without contradiction.

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

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

Two sentences, front-loaded with purpose, no redundant words. Every sentence adds value.

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

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

For a simple list tool with one parameter and no output schema, the description provides enough context: purpose, output fields, connection to reinstall, and read-only nature. Could mention error handling but not necessary for this complexity.

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

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

Schema coverage is 100%, and the parameter description in the schema is sufficient. The tool description adds no new parameter-level information, so 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 it lists OS templates for VPS reinstallation, specifying output fields (template_id + label) and connecting to a sibling tool (impreza_vps_reinstall). This distinguishes it from other 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?

Explicitly says use it to pick a template_id for impreza_vps_reinstall, and declares read-only. It doesn't provide exclusions or alternatives, but the context is clear enough for this simple list tool.

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

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

No annotations are provided, so the description carries the full burden. It discloses behavioral differences between shutdown (graceful ACPI) and stop (hard power-off), and states that these actions take the server offline. This is valuable transparency, though it omits potential data loss risks from hard stop and authentication requirements.

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

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

The description is two sentences, front-loaded with the core purpose and followed by an important caution. Every word adds value; 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?

Given the lack of annotations and output schema, the description covers the essential behavioral aspects of the tool. It explains the actions and provides a usage warning. However, it does not describe the return value, error conditions, or whether the operation is synchronous, which is a minor gap.

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

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

Schema coverage is 100% and both parameters are described, but the description adds context by clarifying the enum values (e.g., 'graceful ACPI' for shutdown, 'hard power-off' for stop) and specifying that service_id comes from impreza_list_services. This goes beyond the schema's brief 'Power action to perform.'

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 'change' and the resource 'Proxmox VPS power state', and enumerates the four specific actions (start, shutdown, reboot, stop). It effectively distinguishes this tool from siblings like impreza_vps_status or impreza_vps_reinstall by focusing exclusively on power state changes.

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 explicit guidance to confirm with the customer before using shutdown/stop, which is a key usage constraint. However, it does not specify when to use start vs reboot, nor does it mention alternatives among siblings (e.g., no other tool handles power). The confirmation note earns a 4.

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

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

The description starts with 'DESTRUCTIVE: ... ALL DATA ON THE VPS IS ERASED', which fully discloses the irreversible nature of the operation. It also mentions password requirements. With no annotations, the description carries the full burden and does so excellently.

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 leads with the most critical information ('DESTRUCTIVE'), then explains the action, and ends with usage guidance. No unnecessary words.

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

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

Given the tool has 3 required parameters and no output schema, the description covers the essential behavior and usage. It could briefly mention what happens after the reinstall (e.g., a confirmation or status update), but the current level is adequate for safe usage.

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

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

The input schema already describes all three parameters (100% coverage). The description adds value by explaining how to obtain `template_id` via a sibling tool and that `password` is the new root password with a minimum length of 8 characters, which goes beyond the schema's description.

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

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

The description clearly states the tool's purpose: 'wipe and reinstall a Proxmox VPS from an OS template'. It specifies the destructive nature and what it does, distinguishing it from sibling tools like `impreza_vps_status` or `impreza_vps_power`.

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

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

The description explicitly says 'Always confirm with the customer before calling', which provides clear when-to-use guidance. It also instructs to use `impreza_vps_list_templates` to pick a template, giving an explicit alternative step.

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

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

With no annotations provided, the description carries full burden. It clearly declares 'Read-only' and lists the data returned (power state, CPU, memory, disk, network, uptime), indicating no side effects. It does not discuss rate limits or authorization, but for a simple status check this is sufficient.

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

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

Two concise sentences: first states action and data returned, second provides prerequisite and safety note. No unnecessary words 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?

Without an output schema, the description fully enumerates returned fields (power state, CPU, memory, disk, network, uptime). It references the prerequisite tool and is self-contained for a simple read operation.

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

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

The sole parameter 'service_id' is described in the input schema with a note to get it from 'impreza_list_services'. The tool description reiterates this context, adding value beyond the schema by clarifying how to obtain the value.

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

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

The description uses a clear verb ('Get') and resource ('Proxmox VPS's live power state + resource usage'), specifying exact metrics (CPU, memory, disk, network, uptime). It distinguishes from siblings like 'impreza_vps_power' which controls power, and 'impreza_list_services' which lists services but not status.

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

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

The description explicitly instructs to find the service_id via 'impreza_list_services' and notes the tool is read-only, implying safe usage. However, it does not explicitly state when to avoid this tool or mention alternatives among siblings.

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