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

Description adds significant behavioral context beyond annotations: 'Two-phase commit', 'Asynchronous: returns a progress_id', and 'Manager-private'. No contradiction with annotations.

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

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

Three concise sentences with no redundancy. Key points front-loaded: action, wildcard support, two-phase commit, async nature.

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?

Explains prerequisites (DNS pointing), two-phase commit, and async result. Missing error handling details, but output schema likely covers return format. Sufficient for the 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 50%; description clarifies aliases parameter (wildcards, DNS prerequisite) and confirmation_token, but does not add meaning for hosting_id and site_id beyond what 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?

Clear verb-resource pair: 'Bind one or more additional FQDNs to a web hosting site'. Distinguishes from siblings like delete_site_alias and list_site_aliases by specifying it adds aliases.

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?

States when to use: adding FQDNs to existing site, no provisioning. Mentions 'Two-phase commit' and async behavior, but lacks explicit when-not-to-use or alternative tools.

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

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

Discloses behavioral traits beyond annotations: GET runs immediately, POST/PUT/PATCH/DELETE follow a two-phase commit pattern, and manager-private endpoints are inaccessible. No contradiction with annotations.

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

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

Two sentences, front-loaded with 'Escape hatch', no redundant words. Each sentence adds critical 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 generic escape hatch with an output schema, the description covers purpose, behavioral pattern, and limitations. Could be slightly more explicit about required parameters for different methods, but 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?

Despite 0% schema description coverage, the description explains the behavioral context for method (GET immediate, others two-phase commit) and implies usage of confirmation_token. However, it doesn't detail the path pattern or query object beyond what 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 it's an 'escape hatch' for any public Infomaniak API endpoint when no dedicated tool exists. It distinguishes itself from sibling tools by specifying it covers undocumented endpoints.

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 'when no dedicated tool exists' and warns that manager-private endpoints are not reachable and to 'use a typed tool instead'. 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?

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint. The description adds value by specifying exactly what is checked (products, domains, etc.), which is not evident from annotations alone. No contradiction with annotations.

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

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

The description is a single sentence of 12 words, front-loading the purpose and listing key issue categories. Every word is necessary and no 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 presence of an output schema and detailed parameter descriptions, the description adequately explains the tool's scope. It covers the main categories of issues and is sufficient for an agent to decide when to call it.

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 detailed parameter descriptions. The tool-level description does not add further meaning beyond what the schema provides, so a 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 scans for 'actionable issues' and enumerates specific categories (expiring, maintenance, locked, operations). This is a specific verb-resource combination that distinguishes it from sibling tools like infomaniak_audit_dns_zones or list 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 implies the tool is for auditing an organization but does not explicitly differentiate from alternatives like infomaniak_overview or other audit tools. No guidance on when not to use it, leaving the agent to infer 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?

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint. The description adds valuable behavioral details: each domain requires 2 sequential API calls, default max_domains=20 keeps execution under ~30s, and the overall bulk-read nature is explained. 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 extremely concise: two sentences that clearly state the purpose and usage context. Every word adds value, with no filler or repetition of schema details. The front-loaded structure immediately conveys the tool's core functionality.

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 an output schema (so return values are covered), three optional parameters with full schema descriptions, and detailed annotations, the description is complete. It covers purpose, behavioral traits (API calls, timing), and parameter tuning cues, leaving no critical 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%, providing baseline clarity. The description adds meaning beyond the schema by explaining the execution time implication of `max_domains` and providing an example for `filter_contains`. This additional context helps the agent make informed parameter choices.

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 performs a 'Bulk-read' of every domain owned by an account, returning DNS record counts and DNSSEC status. It distinguishes from sibling tools like `infomaniak_list_domains` or `infomaniak_dns_list_records` by focusing on a multi-domain audit with specific metrics.

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

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

The description explicitly marks the tool as 'useful for spot-checking large fleets', providing clear context for when to use it. However, it does not offer explicit guidance on when not to use it or mention alternatives, leaving some ambiguity for the AI agent.

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 critical behaviors: the two-phase commit process and the decision to use a private API because the public API silently no-ops. This adds context beyond what annotations (destructiveHint=true, idempotentHint=false) provide, helping the agent anticipate side effects and API 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 one dense sentence that packs purpose, behavior, and rationale. It is front-loaded but could be more readable with a slight structural split. Still, it is efficient with 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 complexity (two-phase commit, private API workaround), the description covers essential context: what it creates, how it operates, and why the alternative API path was chosen. With an output schema present, the agent has enough information 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?

Schema description coverage is 100%, so baseline is 3. The description does not add additional meaning to parameters beyond the schema. However, the schema itself provides adequate details, including hosting_id source and naming 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 verb ('Create'), resource ('a new MariaDB database on a web hosting'), and distinguishes the tool from siblings like delete or get by mentioning the two-phase commit and reliance on a private API. This specificity ensures the agent understands exactly what the tool does.

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 (for creation) but does not explicitly state when not to use it or mention alternatives. The input schema for hosting_id hints at prerequisite tools (infomaniak_find_site, infomaniak_list_hostings), but this is not in the main description, leaving usage guidance incomplete.

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

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

Annotations already indicate destructiveHint=true (mutation) and readOnlyHint=false. The description adds value by explaining the two-phase commit, password policy, and login formatting rules. No contradiction with annotations.

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

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

The description is extremely concise (three sentences) and front-loaded with the primary purpose. Every sentence adds essential information 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?

The description covers creation, two-phase commit, connection types, and password policy. It does not explain the token parameter or two-phase flow in detail, but an output schema is present, reducing the need to document return values. Adequate for a well-annotated 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%, so the schema independently documents all parameters. The description adds context about the two-phase commit (token) and password policy but does not describe each 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 clearly states the action (create), the resource (FTP/SSH user on web hosting), and specifies the connection types. It distinguishes this tool from siblings like 'infomaniak_create_database' or 'infomaniak_create_mailbox' by focusing on user creation for hosting.

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

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

The description mentions 'Two-phase commit', which signals a multi-step process (plan then apply). It distinguishes between 'ftp' and 'ssh' connection types with clear behavioral differences. However, it does not explicitly state prerequisites (e.g., need hosting ID via 'infomaniak_list_hostings') or when not to use this 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?

Adds value beyond annotations by describing two-phase commit process and that password never appears in plan output. Annotations already indicate destructive hint, but description enriches 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, front-loaded with purpose, no filler. Efficiently communicates core workflow.

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

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

Covers main two-phase commit flow and mentions password security. With output schema present, return values are not needed. Lacks mention of prerequisites like valid mail hosting ID.

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

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

Schema coverage is 100%, so baseline is 3. The description itself does not add parameter meaning beyond what the schema provides, but it does mention password security aspect.

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 'Create a new mailbox on a mail hosting' and distinguishes from sibling tools like delete or list mailboxes. Mentions two-phase commit, adding specificity.

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 guidance on two-phase commit (plan then apply) but does not explicitly state when to use this vs alternatives (e.g., creating an alias) or when not to use it.

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

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

Annotations already indicate a destructive write (destructiveHint=true, readOnlyHint=false). The description adds behavioral context by mentioning 'two-phase commit' (implying a multi-step process) and that the alias receives emails. However, it does not explain the two-phase mechanism or what the confirmation token is for.

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

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

The description is two sentences, front-loaded with the action ('Add a new alias to an existing mailbox'), and contains 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 two-phase commit complexity and 4 parameters, the description is incomplete. The two-phase process is not explained, the confirmation_token parameter is not described, and there is no guidance on the return value (though an output schema exists).

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

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

Schema coverage is 0%, so the description must add meaning. It mentions 'alias' but does not explain the parameters mail_hosting_id, mailbox_name, alias, or confirmation_token. The token's role in the two-phase commit is hinted but not clarified.

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 ('Add a new alias to an existing mailbox') and distinguishes it from sibling tools like infomaniak_create_mailbox (creates mailbox, not alias) and infomaniak_list_mailboxes (list, not create). The mention of 'two-phase commit' adds specificity.

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 a two-phase process but does not explicitly state when to use this tool, prerequisites (e.g., mailbox must exist), or when not to use it. There is no comparison to alternatives like infomaniak_create_redirection.

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

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

Annotations already indicate destructiveHint=true and readOnlyHint=false; description adds the two-phase commit detail and forwarding behavior. No contradiction, but could mention permissions or reversibility.

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 redundant text, front-loaded with the action. Every sentence adds value.

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

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

Given the output schema exists and parameters are well-documented, the description is adequate but lacks details on the plan step of the two-phase commit, which could confuse the 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% so the schema provides full parameter documentation. The description adds minimal extra value beyond the schema, so 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?

Description clearly states 'Create a server-side mail redirection' and explains the forwarding behavior. It distinguishes from siblings like list_redirections and delete_redirection.

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?

Mentions 'Two-phase commit' but does not explain when to use the plan vs apply phase or provide explicit alternatives. Usage context is implied but not fully clarified.

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

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

Annotations indicate mutation (destructiveHint=true), and description adds 'Two-phase commit', a critical behavioral trait not in annotations. Provides additional context about the commit pattern.

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 waste, front-loaded with purpose. 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?

Complex tool with two-phase commit and preconditions, but description covers key points. Output schema exists, so return values need not be described. Adequately complete 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?

With 100% schema coverage, baseline is 3. Description adds value by explaining the confirmation_token's role as 'token from the prior plan response' and reinforces target URI requirement. Enhances understanding 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 'Create a new short URL pointing to a long target', distinguishing it from sibling list/quota tools. The two-phase commit adds specificity.

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 tells to use infomaniak_short_urls_quota first for headroom check, providing clear context on when to use this tool and when to check alternatives.

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

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

Discloses the two-phase commit behavior beyond annotations, including the plan and confirmation_token flow. Annotations already indicate destructive and non-read-only nature, but the added workflow details are valuable.

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 front-loaded purpose and efficient description of the two-phase commit. Every sentence 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?

Covers the two-phase workflow but lacks details on the return value of the first call (the plan) and how to interpret the confirmation_token. Output schema may cover return values, but the description could be more complete for a complex 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 0%, but description only mentions parameters generically ('same params + token'). Does not explain the role of hosting_id, fqdn, directory, or environment, failing to add meaning over 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 creates a new site on an Infomaniak web hosting, with specific verb 'creates' and resource 'site'. Distinguishes from siblings like delete_site or find_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?

Describes the two-phase commit process, making clear how to use the tool in two calls. Does not explicitly mention alternatives or when not to use, but the creation context is well-defined.

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

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

Beyond annotations (destructiveHint=true), the description reveals the fallback behavior, the two-phase commit, and that the plan phase exposes current certificate status. This adds valuable context without contradicting 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 with zero waste. Key information is front-loaded: the action and its immediate effect. The structure is efficient and clear.

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

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

Given the destructive nature and two-phase flow, the description covers the essential behavioral context (fallback, undo). The presence of an output schema reduces the need to describe return values. Minor omission: no mention of prerequisites like owner permissions.

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 detailed parameter descriptions. The tool description does not add additional information about parameters beyond what the schema already provides, 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 it deletes the SSL certificate of a site and specifies the consequence (fallback to no HTTPS or default cert). It distinguishes itself from siblings like infomaniak_get_certificate and infomaniak_request_certificate by mentioning the two-phase commit and the undo option.

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 outlines the two-phase commit process: omit token to get plan+token, re-pass to execute. It also provides an undo alternative via infomaniak_request_certificate. However, it does not specify when *not* to use this tool, though the destructive nature is 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 indicate destructiveHint=true. The description adds a clear warning about irrecoverable data loss and mentions the two-phase commit process, providing behavioral context beyond annotations.

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

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

The description is three short sentences without redundant information. It front-loads the purpose and immediately follows with behavioral traits (two-phase) and a critical warning.

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 destructive nature, annotations, and existing output schema, the description covers the key workflow (two-phase commit, warning) and parameter origin. It could mention the need to call a plan phase first, but the confirmation_token parameter hints at this.

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

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

With 100% schema coverage, baseline is 3. The description adds value by explaining the confirmation_token's origin ('from the first (plan) phase') and notes that database_name includes the hosting prefix, which complements the 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 'Delete a MariaDB database', specifying the verb (delete) and resource (MariaDB database). It distinguishes from sibling delete tools (e.g., delete_site, delete_mailbox) by naming the database type.

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 via 'Two-phase commit, manager-private API' and a warning about data loss, but it does not explicitly state when to use this tool vs alternatives or 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?

The description adds value beyond annotations by explaining the two-phase commit and that files are preserved. Annotations include destructiveHint=true and idempotentHint=true, and the description does not contradict them, though the two-phase nature might slightly complicate idempotency. Overall, good additional context.

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

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

Three sentences with no waste. The main action is front-loaded, and key details (two-phase, file preservation) are provided succinctly.

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, the description covers the two-phase process and file preservation. An output schema exists, so return values are not required. However, it could briefly mention what the first call returns (plan + token), but overall sufficient.

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

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

Schema description coverage is 100%, but the description adds extra meaning: it specifies that 'login' includes the hosting prefix and explains the two-phase use of 'confirmation_token'. This goes beyond the schema's own 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 action ('Revoke a hosting user'), the specific resource (FTP/SSH access), and unique details (two-phase commit, files not deleted). It distinguishes from sibling tools like infomaniak_create_hosting_user.

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

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

No explicit guidance on when to use this tool versus alternatives (e.g., other delete tools). The two-phase commit implication is present but not detailed, and no when-not-to-use advice is given.

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 it as destructive. The description goes beyond by explicitly warning that all stored emails are deleted and by mentioning the two-phase commit process, providing important behavioral context.

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

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

The description is two sentences with no wasted words. It front-loads the action and includes critical warnings efficiently.

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

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

The description covers the essential aspects (action, two-phase commit, destructive consequence). It could briefly explain the two-phase commit flow, but the parameter description for confirmation_token compensates partially. With output schema existing, completeness is adequate.

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 descriptions already cover parameters. The main description adds no new semantic information about parameters beyond what is in the schema, hence a 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 clearly states the action 'Delete a mailbox' and the resource, and includes a warning about deleting stored emails. The two-phase commit detail adds clarity and distinguishes it from other deletion 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 does not explicitly state when to use this tool compared to alternatives. While parameter descriptions hint at prerequisites (e.g., verify mailbox with list), the main description lacks direct usage 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 mentions 'Two-phase commit', which is critical behavioral information beyond annotations. Parameter descriptions further detail the two-step process: omit token for plan, pass token for deletion. Annotations already indicate destructive and idempotent, but the description adds workflow 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 main description is only two short sentences, directly stating purpose and key behavioral trait. No unnecessary words, and the most important information is front-loaded.

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

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

The main description is brief but combined with parameter descriptions and annotations, the tool definition is quite complete for an agent. The two-phase process is fully explained in the confirmation_token parameter. Minor improvement would be to add the two-phase mention in the main description, but current level is sufficient.

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

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

All three parameters have detailed, actionable descriptions in the input schema, such as 'Discover via infomaniak_list_mail_hostings' for mail_hosting_id and 'List existing rules with infomaniak_list_redirections' for name. This adds significant meaning beyond type/format.

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

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

The description clearly states 'Delete a mail redirection', specifying the action and resource. It distinguishes from sibling tools like 'infomaniak_create_redirection' and 'infomaniak_list_redirections'.

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?

Parameter descriptions provide usage guidance: 'name' advises listing existing redirections first, and 'confirmation_token' explains the two-phase commit workflow. However, the main description lacks explicit when-to-use or when-not-to-use guidance compared to alternatives.

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

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

Annotations already indicate destructive and idempotent behavior. The description adds critical details about the two-phase commit, grace period, and FTP deletion, which go beyond annotations and enhance 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?

Two concise sentences that front-load the core purpose and key behaviors. Every word serves a purpose with no 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 annotations and output schema, the description provides all necessary context: the two-phase commit, required parameters, and consequences (FTP deletion). No 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 coverage is 100%, so the description adds value by clarifying the confirmation_token's role in the two-phase process. This is useful context 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 clearly states the tool deletes a site from Infomaniak web hosting, using specific verbs and resources. It distinguishes from siblings like 'infomaniak_create_site' by focusing on deletion.

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

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

The description explains the two-phase commit process and warns about wiping the FTP directory. It doesn't explicitly mention when not to use or provide alternatives, but the context is sufficient.

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 annotations: 'Two-phase commit' implies a confirmation step, 'Manager-private' implies access control, and it clarifies that the main FQDN cannot be removed. No contradiction with annotations (destructiveHint=true, readOnlyHint=false).

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, front-loading the action and key constraint. However, 'Manager-private' is cryptic and could be clearer. Otherwise, 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?

For a delete alias tool with an output schema and destructive annotation, the description covers the core behavior, effect (vhost no longer responds), and constraints. It lacks explicit prerequisites (e.g., that hosting_id and site_id should come from list tools) but is otherwise complete.

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

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

Schema description coverage is only 25%, and the description adds minimal parameter-level detail. While the alias parameter has a detailed schema description, the description does not elaborate on other parameters (e.g., hosting_id, site_id) or the confirmation_token's role in the two-phase commit. The description could compensate more for the low coverage.

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

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

The description clearly states the action (remove), the resource (alias FQDN), and the constraint (cannot remove main FQDN). It distinguishes from sibling tools like infomaniak_add_site_aliases and infomaniak_list_site_aliases.

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

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

The description mentions 'Two-phase commit' and 'Manager-private', but does not explicitly state when to use this tool vs alternatives (e.g., when not to use it, or when to use other site alias tools). The usage context is implied but not fully specified.

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 set destructiveHint=true, readOnlyHint=false. The description adds the key behavioral detail of the two-phase commit process, which is not captured in annotations. It does not contradict annotations. The description could have elaborated on rate limits or authentication requirements, but the two-phase commit insight is valuable.

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. The first clearly states the purpose, and the second explains the critical two-phase commit workflow. 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?

For a tool with 6 parameters, 100% schema coverage, and an output schema, the description is sufficient. It notes the plan+token return from the first call, which compensates for the lack of explicit return value explanation. The description could mention idempotency (annotations say false) but is otherwise 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?

With 100% schema coverage, baseline is 3, but the description adds significant meaning: zone explains domain management check, source clarifies '.' for apex, type mandates UPPERCASE, target explains inline priority for MX/SRV, ttl provides defaults, and confirmation_token links to the plan phase. This greatly aids correct parameter usage.

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

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

The description clearly states 'Create a DNS record on an Infomaniak-managed zone' and details the two-phase commit process, distinguishing it from sibling tools like infomaniak_dns_delete_record, infomaniak_dns_list_records, and infomaniak_dns_update_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 explicitly explains the two-phase commit protocol: 'first call returns a plan + token, second call (same params + token) actually creates the record.' It also hints at prerequisites via the zone parameter description (check managing domain). However, it does not explicitly state when not to use the tool or list alternatives.

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

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

Annotations already indicate destructiveHint=true and readOnlyHint=false. The description adds crucial behavioral detail about the two-phase commit, including the plan preview and token mechanism. This goes beyond 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 three sentences, front-loaded with purpose, then process, then token clarification. Every sentence adds value with no redundancy. 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 an output schema exists, return values need not be detailed. The description covers the two-phase process, parameter specifics, and token usage. It could mention idempotency of the delete phase, but the annotation idempotentHint=true partially covers that. Overall complete for its purpose.

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 all three parameters. The description adds meaning: zone must be a domain with DNS managed by Infomaniak; record_id is numeric from list_records; confirmation_token comes from the plan phase and includes a preview. This enriches 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 'Delete a DNS record from an Infomaniak-managed zone' with a specific verb and resource. It distinguishes itself from sibling tools like infomaniak_dns_create_record and infomaniak_dns_update_record by focusing on deletion and the unique two-phase commit process.

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 explains the two-phase commit: first call returns a plan and token, second call executes the deletion. It advises verifying the plan preview before confirming, which provides clear usage context. It lacks an explicit when-not-to-use statement but is still well-guided.

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 readOnly and idempotent behavior. The description adds no behavioral traits beyond the input constraint (root domain). It does not contradict annotations.

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

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

Two short sentences with no wasted words. The action statement and usage constraint are front-loaded and precise.

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 1 parameter and rich annotations (readOnly, idempotent, openWorld) plus an output schema, the description covers all necessary context: what it does, what input it expects, and how to format it.

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 'zone' parameter as root domain. The description reinforces this and adds the explicit 'not a subdomain' rule, providing additional clarity 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 ('List every DNS record') and the resource ('a zone managed by Infomaniak'), distinguishing it from sibling tools like create/delete/update. It also specifies the correct input format (root domain, not subdomain).

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 usage constraint ('Use the root domain, not a subdomain'), but does not explicitly compare with alternatives or state when not to use. However, the purpose is clear enough given the 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?

The description adds significant behavioral context beyond annotations: the two-phase commit, token requirement, and preview behavior. Annotations indicate destructiveHint=true and idempotentHint=true, which align with the description. 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 long, front-loaded with the main purpose, and every sentence adds value. 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 complexity (two-phase commit), the description covers the essential flow. The presence of an output schema likely handles return value documentation, so no further details are needed.

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

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

Schema description coverage is 0%. The description only adds meaning for the confirmation_token parameter by explaining its role in the two-phase commit. Other parameters (zone, record_id, source, type, target, ttl) receive no additional semantics, leaving the agent to rely solely on parameter names and types.

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

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

The description clearly states the tool updates one or more fields of a DNS record, distinguishing it from sibling tools like infomaniak_dns_create_record and infomaniak_dns_delete_record. The verb+resource combination leaves no ambiguity.

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

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

The description explicitly outlines the two-phase commit process: first call to preview changes and get a token, second call to apply. It provides clear procedural guidance but does not explicitly mention when not to use it or alternative tools.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, indicating safe repeated reads. The description does not add behavioral context beyond stating it returns the definition. No side effects or auth requirements are mentioned, which is acceptable given the annotations.

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

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

The description is a single, well-structured sentence that succinctly conveys the tool's purpose and the content of its output. No superfluous 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 presence of an output schema and clear annotations, the description is largely complete. It captures the essential function and could be improved by noting the format of the returned definition, but it is adequate.

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 covers 100% of the single parameter 'tool' with a description. The tool description does not add additional semantic meaning beyond what the schema already provides. 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's function: 'Returns the full definition of a specific tool' and lists the components (description, annotations, parameters, output shape). It distinguishes itself from siblings, as it is a meta-tool for obtaining information about 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?

Usage context is implied by the description (useful for learning about a tool), but there is no explicit guidance on when to use it versus alternatives or when not to use it. The sibling tools are all action-oriented, so the purpose is clear, but no exclusions are mentioned.

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

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

Annotations already indicate readOnlyHint, idempotentHint, and openWorldHint. The description adds behavioral context beyond these by noting it is 'significantly cheaper than calling list_hostings + list_sites manually because it short-circuits on the first match.' This provides valuable performance insight 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?

The description is very concise: two sentences that cover purpose, return structure, usage guidance, and performance note. Every part adds value without redundancy. It is front-loaded with the core action and result.

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 and the presence of an output schema, the description is complete. It explains what the tool does, when to use it, what it returns, how parameters work, and why it's efficient. No gaps remain for an AI agent to select and 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 baseline is 3. The description enriches parameter semantics: for 'domain', it accepts root/sub-domains and Punycode; for 'account_id', it explains the optionality and scope of lookup (scanning all accounts vs. restricting). This goes beyond the 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 tool's purpose: to locate a domain in the Infomaniak account tree. It specifies the verb 'locate', the resource 'domain', and lists the returned fields (account_id, hosting_id, etc.). This distinguishes it from sibling tools like list_hostings and list_sites, which are more expensive alternatives.

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 on when to use the tool: 'Use this BEFORE any tool that requires hosting_id + site_id (get_certificate, request_certificate, list_databases, etc.) when you only know the domain name.' It also contrasts with manual alternatives, making the usage context very clear.

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

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

Annotations already indicate readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=true. The description adds context about access restriction ('Manager-private') and detailed response fields, going beyond what annotations provide.

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

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

The description is a single concise sentence that front-loads the purpose ('Full organization detail') and lists key fields without waste. It is appropriately sized for the tool's simplicity.

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

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

Given the presence of an output schema and rich annotations, the description provides sufficient overview of the returned data. It lists many fields, which complements the schema, but is 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 input schema covers 100% of parameters, with the account_id already described as 'Account/organization id. Discover via infomaniak_list_organizations.' The tool description does not add further parameter meaning 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 retrieves full organization details including legal entity, billing, VAT, locale, timezone, logo URLs, support tier, 2FA policy, user role, counts, and tags. This distinguishes it from sibling list tools like infomaniak_list_organizations.

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 it's for managers ('Manager-private'), but does not explicitly state when to use this tool versus alternatives. It lacks guidance on when not to use it or which sibling tool to use instead for simpler queries.

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

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

Annotations already indicate readOnlyHint, idempotentHint, and openWorldHint, reducing the burden. The description adds value by detailing the specific return fields (provisioning state, type, validity flags, timestamps, etc.), providing behavioral context beyond annotations.

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

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

The description is a single sentence that front-loads the main purpose and lists features. It is efficient with no wasted words, though the list of fields makes it slightly long.

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

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

With an output schema, the description need not explain return values, but it does so helpfully. However, it omits how to obtain the required IDs (e.g., from list hostings/sites) and does not address error cases like missing certificates. Adequate but not fully complete.

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

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

Schema coverage is 0%, so the description must compensate. It only implies that hosting_id and site_id identify a site on a web hosting, but does not define them clearly or indicate how to obtain them. This is insufficient for a tool with only two parameters.

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 returns the full SSL certificate detail for one site on a web hosting, and lists many specific fields. It distinguishes well from sibling tools like infomaniak_request_certificate and infomaniak_delete_certificate.

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 certificate details but does not explicitly state when to use this tool versus alternatives like infomaniak_list_sites or infomaniak_get_domain. No prerequisites or exclusions are mentioned.

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

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

Annotations declare readOnlyHint, idempotentHint, and openWorldHint. The description adds context by specifying what details are included (disk usage, application, permissions, backups). No contradictions; the description complements annotations well.

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 18 words, front-loading the main action and then listing key attributes. Every word is informative with no redundancy.

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

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

Given the presence of an output schema, the description does not need to explain return values. It lists included details, which is sufficient. The agent can infer required parameters from the schema. Slightly lacking in providing prerequisites or context about when to use this tool over others, but still complete enough.

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

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

The description adds no information about parameters beyond what is in the schema. Schema description coverage is 50% (database_name has a description, hosting_id does not). The tool description should compensate but does not, offering no additional meaning for parameters.

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') and resource ('full detail of a specific database'), listing specific attributes (disk usage, application, permissions, backups). This distinguishes it from sibling tools like infomaniak_list_databases (list only) and infomaniak_get_database_user (user 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 implies usage for retrieving full details of a specific database, but does not explicitly state when to use this tool vs alternatives like infomaniak_list_databases or infomaniak_get_database_user. No exclusions or context are 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?

Annotations already declare readOnlyHint, idempotentHint, openWorldHint. The description adds value by specifying what details are fetched (applications, permissions, phpMyAdmin link), which is beyond the annotations. No contradiction 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 a single, front-loaded sentence of 17 words, with no wasted verbiage. It efficiently conveys the tool's 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 has an output schema (not shown), so return values are documented. The description adds context about what is fetched. With two parameters (one described) and annotations, the description is adequate, though slightly more detail on behavior could push it to 5.

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

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

Schema description coverage is 50% (user_name has description, hosting_id does not). The tool description does not add meaning to parameters, missing the opportunity to clarify hosting_id or the format of user_name. With low coverage, description should compensate but doesn't.

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

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

The description clearly states the verb 'Fetch' and the resource 'detail of a single MariaDB-level user', and specifies the content (applications, permissions, link to phpMyAdmin). It distinguishes from sibling tools like infomaniak_list_database_users (list) and infomaniak_get_database (get database).

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

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

The description provides no guidance on when to use this tool versus alternatives, nor does it mention prerequisites or when not to use it. The name implies getting a specific user, but explicit usage context is missing.

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

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

Annotations already indicate read-only, idempotent, and open-world behavior. The description adds value by specifying the exact data returned (DNS management status, DNSSEC, IDN, errors), providing behavioral context beyond annotations.

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

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

The description is a single sentence, front-loaded with key information, and contains no redundant words. It is appropriately concise for a straightforward tool.

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

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

Given that the tool has an output schema (not shown but known from context), the description need not detail return values. The description covers the essential aspects, and annotations cover safety. It is complete for its purpose.

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

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

The input schema has 100% coverage with a clear description for the single parameter 'domain'. The tool description does not add any additional parameter semantics; it meets 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 clearly specifies the verb 'Get' and the resource 'domain', and lists specific aspects (DNS management status, DNSSEC, IDN, errors). This distinguishes it from sibling tools like infomaniak_list_domains (for listing all domains) and infomaniak_manage_dnssec (for managing DNSSEC).

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 detailed information about a single domain is needed. Although it does not explicitly mention alternatives, the sibling tools list provides context and the purpose is self-explanatory. Slightly lacking explicit when-not 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 readOnlyHint=true and destructiveHint=false. The description adds valuable behavioral context: the tool returns sensitive data (auth_code) and notes 'Manager-private' (permission requirement). No contradictions. Adds beyond annotations.

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

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

The description is a single sentence but packs many specific data items. It is front-loaded with 'Full domain detail'. Slightly long but efficient; no wasted words. Could be broken into bullet points for readability, but still good.

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 annotations cover safety and output schema exists (not shown but implied), the description is fairly complete: lists return contents, input format, and permission note. It lacks details on pagination or response size, but being read-only with openWorldHint, this is sufficient.

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

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

Schema coverage is 100%, so the schema already documents the parameter well. The description repeats that it accepts id or FQDN and adds a discovery hint. This is adequate but does not significantly enhance 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 explicitly lists many specific data fields (auth_code, transfer_status, glue records, etc.) and states 'Full domain detail', clearly differentiating from simpler sibling tools like infomaniak_get_domain. The verb 'get' plus 'full' accurately describes the resource and scope.

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

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

The description explains how to specify the domain (id or FQDN) and references infomaniak_list_domains for discovery. Although it doesn't explicitly contrast with simpler alternatives, the naming and content imply when to use this comprehensive version. Clear context for 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?

Annotations already indicate read-only, idempotent, and non-destructive behavior. Description adds that the tool uses a private manager API, which provides authentication context beyond annotations. No contradictions.

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

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

Two concise sentences with no extraneous content. Every sentence adds value: first describes purpose and fields, second provides use case and sibling differentiation.

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 get tool with output schema present, the description covers purpose, fields, use case, and API type. No gaps given the context signals and schema coverage.

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 the single parameter drive_id with description. Description only mentions discovering it via infomaniak_list_drives, which adds minimal value beyond schema. Baseline 3 for high coverage, slight improvement but not significant.

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

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

Description clearly states it returns full kDrive detail including specific fields (name, sizes, timestamps, maintenance flag) and explicitly distinguishes from sibling tool infomaniak_list_drives, which uses a public API.

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?

Indicates tool is for storage usage monitoring and notes it is manager-private, contrasting with the public Bearer API of the sibling. While it doesn't explicitly state when not to use, the distinction is clear.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint. Description adds value by listing specific fields returned and noting 'Manager-private' access restriction, which goes beyond what annotations provide. 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?

Description is a single verbose sentence listing many fields; it is adequately concise but could be more structured (e.g., bullet list) for easier scanning. Purpose 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 existence of an output schema, the description sufficiently covers the tool's return content and access context. It explains what fields are included and mentions use cases, but does not address relationship with similar 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 50% (only mailbox_name has a description). The description does not add any parameter documentation beyond the schema, leaving the mail_hosting_id parameter undocumented.

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

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

Description clearly states it returns 'Full mailbox detail' and lists many specific fields, distinguishing it from the sibling 'infomaniak_get_mailbox_info' by name and scope. However, it does not explicitly contrast with that sibling.

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 usage context ('useful for mailbox audits and onboarding flows'), but does not explicitly state when not to use it or mention alternatives like get_mailbox_info for basic queries.

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

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

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint. The description adds valuable behavioral context: the tool hits endpoints in parallel for selected fields, and it is a replacement for three older tools. 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?

Two concise sentences that front-load the purpose and immediately explain the key feature (subset selection via fields). 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?

The description fully covers the tool's purpose, behavior (parallel requests, replacement of old tools), and parameter usage. An output schema exists for return values, so the description need not detail them. Complete for the tool's 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?

Schema coverage is 100%, so parameters are well documented. The description adds meaning by explaining that the `fields` argument allows picking a subset and that the tool only hits corresponding endpoints in parallel, which goes beyond the schema's default listing.

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

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

Description clearly states it reads mailbox metadata, specifies the exact fields it can retrieve (aliases, signatures, backups) via the `fields` argument, and explicitly mentions it replaces three older tools. This distinguishes it from sibling tools that perform other operations like listing or creating mailboxes.

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 using the tool: retrieve mailbox metadata in one call, with the ability to pick subsets. It explicitly notes it replaces the v0.9 trio, guiding away from older tools. However, it does not include explicit when-not-to-use or alternative scenarios, though the context is still strong.

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

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

Annotations already provide safety profile (readOnly, non-destructive, idempotent). The description adds the 'Manager-private' qualifier, indicating authorization requirements beyond annotations. It accurately describes the return content without contradicting 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 only: first immediately lists key fields; second gives clear usage hint. Every sentence adds value, no 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?

Output schema exists, so return values need no description. The description covers all key fields (DNS health, quotas, admin, etc.) and parameter is well-documented in schema. Complete for a read-only single-resource 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% and parameter description already guides discovery via infomaniak_list_mail_hostings. The tool description adds no further semantic value for the parameter, 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 explicitly states 'Full mail hosting detail' and enumerates specific fields (diagnostic_dns health check, quotas, admin user, etc.), distinguishing it from siblings like infomaniak_get_mailbox_full (single mailbox) and infomaniak_list_mail_hostings (list only).

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 states 'Use this for mail-config sanity checks' and includes 'Manager-private' hinting at access restrictions. The parameter description advises discovery via infomaniak_list_mail_hostings. However, it does not explicitly exclude alternatives or specify when not to use.

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

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

Adds authentication requirement (SASESSION cookie), privacy level (Manager-private), and lists returned fields, supplementing the safe annotations.

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

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

Two concise sentences: first covers purpose and output, second covers usage. 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?

For a zero-parameter read tool with output schema, the description fully explains what it returns and when to use it.

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, schema is empty. Description compensates by enumerating all returned fields, adding meaningful 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?

Description clearly states it retrieves the authenticated user's identity with specific fields listed. Distinct from sibling tools like infomaniak_get_my_security.

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 recommends using this tool first to confirm user and account context. No exclusions but strong usage guidance.

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