Page Lemon

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

Annotations already declare this is non-read-only, destructive, non-idempotent, and open-world. The description adds some useful context beyond that with "two-step" and the owner opt-in requirement, but it does not explain what the destructive aspect means, what happens on duplicate entries, or how confirm_token is obtained.

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?

It is short, and the verb is front-loaded, but the parenthetical is syntactically awkward and obscures the intended workflow. The content is concise without being clear, so structure is only marginally adequate.

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

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

This is a six-parameter mutation tool with a nested values object, a required confirm_token flow, and destructive behavior. Even with an output schema present, the description does not provide enough operational context to call it safely and 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 0% across 6 parameters, so the description must carry parameter meaning. It only vaguely gestures at values and group sharing; it says nothing about site, list, member, or confirm_token, leaving most required inputs unexplained.

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 says it "Adds an entry for a user," which gives a verb and a rough target, but it never clearly states that this entry goes into a list/app row or how that differs from siblings like add_list_items. The parenthetical "to read (values; group shares it with the group, two-step)" muddies rather than sharpens the purpose.

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

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

The phrase "two-step" hints at a confirmation flow, but there is no explicit when-to-use guidance, no exclusion against add_list_items or update_app_rows, and no stated prerequisites beyond the vague "Needs the owner's opt-in." An agent would have to infer when this tool is the right choice.

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

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

Annotations already declare the safety profile (destructiveHint=true, openWorldHint=true, non-idempotent), and the description adds genuinely new context: the webhook is signed, the signing secret is never returned by the API (Dashboard only), and the operation is a two-step flow. It stops short of explaining what happens to existing webhooks or what the intermediate step returns.

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 short, front-loaded clauses with no filler; the verb and resource come first and the caveats follow. Density is high, though 'ids only' is terse to the point of ambiguity.

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?

An output schema exists, so return values needn't be spelled out, and the destructive/open-world profile is covered by annotations. The unresolved gap is the two-step flow: the description names it but never explains how confirm_token is obtained or used, which is the one thing an agent must know to complete the call.

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

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

Schema coverage is 50%: url and events are documented in-schema (including default-all and event name examples), while site and confirm_token are bare. The description partially compensates by implying site takes an ID ('ids only') and that confirm_token belongs to the two-step flow, but it never explains the token's origin or lifetime.

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

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

States a specific verb and resource ('Adds a signed app-event webhook') and adds a distinguishing trait (signed events, ids only), so an agent can tell it apart from remove_app_webhook. The phrase 'ids only' is cryptic and could mean either input or output is ID-based, which blunts the precision slightly.

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?

'Two-step' combined with the confirm_token parameter implies a two-call confirmation flow, which is useful implied guidance. However, it never says when to prefer this over remove_app_webhook or other add_* siblings, nor what the first step actually requires or returns to trigger the second.

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

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

Annotations already declare destructiveHint=true, openWorldHint=true, idempotentHint=false, so the safety profile is carried by structured data; the description adds genuinely new behavior: clash handling returns 409, force bypasses the conflict check (i.e. double-booking is possible), and confirm_token is a prerequisite for notifying the customer. It does not describe side effects like notifications defaulting on or what a series creates, leaving a small gap.

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 dense sentences with the purpose front-loaded, followed by the mutating edge cases (clash/force) and the prerequisite (confirm_token). No filler; every clause carries information an agent needs.

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 16-param, nested-object mutation tool, the description covers the creation flow, series behavior, conflict semantics, and the notification prerequisite, and an output schema exists so return values need no explanation. The remaining gaps are secondary optional fields, not blockers to correct invocation.

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

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

With 16 params at 50% schema coverage, the description does real compensatory work: it maps 'service, start, customer details', explains the weekly series semantics, characterizes resource as 'staff or a room', and covers force and confirm_token. Unmentioned params such as party, notes, answers, and plugin_id remain undocumented anywhere, so it is helpful but not complete.

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

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

States a specific verb and resource ('Adds a booking') and immediately narrows scope to owner-taken bookings (phone, walk-in), which distinguishes it from the customer-facing booking flow and from edit_booking/approve_booking siblings. The clause listing service, start, customer details, weekly series, and staff/room resource tells an agent exactly what kind of record is created.

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?

Gives clear context for use ('a booking the owner took (phone, walk-in)') and names two conditional paths: clashes return 409 and force:true overrides it, and emailing the customer requires confirm_token first. It does not explicitly say when to prefer edit_booking or get_free_slots instead, so it stops short of full when/when-not/alternatives 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?

Goes well beyond the annotations by disclosing what the call produces (DNS records, one-click apply_url, share_url for the DNS operator) and the re-call-to-check-status pattern, which is consistent with idempotentHint=false. It also surfaces the owner/paid-plan precondition and the claim workflow. Missing only failure modes (what happens on an unverified or conflicting domain).

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 purpose is front-loaded, which is good, but the body is a dense semicolon chain with terse fragments like "again: its status" and "claim: true proves..." that read like notes rather than prose. Every clause carries information, but the structure makes it harder to parse than necessary.

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 present, return values needn't be spelled out, yet the description helpfully names the key artifacts (DNS records, apply_url, share_url). Prerequisites, the www default and the claim loop are all covered. A brief note on failure/conflict behavior would make it complete.

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

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

Schema coverage is 80%, so the schema already documents claim, hostname, domain and confirm_root; the description restates the claim semantics and hints at the www-vs-root choice. It adds no clarification of the domain/hostname duplication or of confirm_root specifically, so it neither compensates for nor meaningfully exceeds 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?

Opens with a specific verb+resource: "Connects the user's own domain to a site." The parenthetical adds scope (owner, paid plans, www is easiest), making the action distinguishable from remove_domain or get_domains. It stops short of explicitly naming the sibling tools, so it's clear but not maximally differentiating.

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?

Gives real usage context: only the site owner can do this, it requires a paid plan, and www is the easiest hostname form. The claim=true branch is scoped to reserved domains or domains held by another account. There are no explicit exclusions or named alternatives (e.g. use get_domains to inspect first), which keeps it below a 5.

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

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

It adds crucial behavioral context beyond annotations, specifying functional limits (up to 500 items), performance characteristics ('within seconds'), and the complex business logic of using form replies.

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 definition is dense but highly efficient, packing functional limits, performance metrics, and a specific usage workflow into two succinct sentences.

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 high complexity (8 parameters, nested objects), the description provides enough operational logic and workflow constraints for an agent to confidently determine when and how to execute the 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?

With schema coverage at 63%, the description significantly helps define the usage of complex fields, particularly clarifying that parameters like 'copy' and 'from' relate to form replies and their required workflow.

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 primary function (adding items to a list). While it doesn't explicitly define the scope relative to all other list manipulation tools, the verb 'Adds' distinguishes it from delete or update operations.

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

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

The description provides a highly specific workflow guideline for usage, detailing the necessary sequence of events involving form replies: preview, consent, and confirmation token required after user agreement.

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 disclose that this is a destructive, non-idempotent, open-world mutation. The description adds some role context and mentions returning approve_url, but it does not explain approval flow, notification behavior, or what access changes entail beyond 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 front-loaded sentence with no filler. However, the role list is dense and somewhat cryptic, especially 'developer (workspace: a seat)' and 'custom+group'.

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

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

For a destructive access-granting tool with seven parameters, the description is minimally adequate. It covers the core purpose and role values, but omits key usage distinctions and parameter details, even though the output schema covers return values.

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 57%, so the description must help with the undocumented parameters. It clarifies role values such as developer, viewer, admin, custom+group, and member, but leaves site, group, emails, notify, permissions, and confirm_token largely unexplained.

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

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

The description states a specific verb and resource: giving people access or setting a workspace person's role. It is clear what the tool does, but it does not explicitly differentiate itself from sibling tools such as invite_users or remove_people.

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

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

The phrase 'Gives people access, or sets a workspace person's role' implies the usage context, but there is no explicit when-to-use guidance, no exclusions, and no comparison to alternatives like invite_users.

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

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

The annotations already declare this is a non-read-only, open-world, non-destructive, non-idempotent operation. The description adds meaningful behavior beyond annotations: the first call returns setup_summary, confirm_token is what saves the plugin, and snippet_html is returned after confirmation. It does not cover error cases, token expiry, or permissions beyond the paid-plan note.

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 compact and front-loads the core action and paid-plan scope. The parenthetical and semicolon-heavy phrasing is terse and slightly cryptic, but it packs substantial workflow information without wasted text.

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

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

For an 8-parameter mutation tool with nested objects and an output schema, the description covers the essential add-plugin workflow and confirmation behavior. It leaves some gaps around the payments kind and the relationship to update_plugin, but the schema and annotations carry much of the remaining detail.

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 63% schema description coverage, the description compensates well for the most important gaps: it explains the kind/settings/forms/form_html branching and gives confirm_token special meaning. It still does not clarify lang, name, or the payments/booking-specific parameter expectations beyond the high-level workflow.

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 specific action and resource: 'Adds a plugin to a site (paid plans)'. It also signals variant behavior for settings versus forms/form_html, though it does not explicitly distinguish this tool from update_plugin or remove_plugin.

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

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

It gives useful usage context: paid plans, a reference to list_plugins settings_help for settings, the forms/form_html path when kind is forms, and the multi-step setup_summary/confirm_token/test_plugin flow. It lacks an explicit statement of when to use this instead of update_plugin, but the add-versus-update distinction is relatively 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 destructiveHint=true, idempotentHint=true and openWorldHint=true, so the safety profile is covered. The description adds the customer email side effect and the waitlist-conversion behavior, but says nothing about reversibility (whether an approval can be undone via cancel_booking), failure modes, or what the plugin_id toggle changes.

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

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

Two sentences, zero filler, with the core action and its side effect front-loaded and the special-case input mode immediately after. Every clause carries information an agent cannot get from the schema or annotations.

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?

An output schema exists, so return values need no explanation, and annotations cover safety. What remains thin is recovery behavior (can an approved booking be reverted?) and the effect of plugin_id defaulting to the booking page, both relevant for a destructive mutation.

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 only 50% schema description coverage, the description meaningfully compensates for item_id by revealing it also accepts wl_ waitlist entry ids — a non-obvious format constraint. It says nothing about the required site parameter or the message field beyond what the schema already documents.

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

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

States a specific verb and resource (approve a booking) plus its immediate side effect (emails the customer), and clarifies a second mode where a waitlist entry_id is accepted as item_id. It is clearly distinguishable from add_booking, cancel_booking and edit_booking by name semantics, though it never names a sibling explicitly.

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

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

The waitlist sentence gives a concrete usage context that an agent would otherwise not infer: passing a wl_… id books that person in immediately rather than performing a plain approval. What is missing is an exclusion rule against nearby siblings such as edit_booking or set_booking_outcome, so routing depends partly on inference.

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

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

Annotations already declare destructiveHint, non-idempotent and open-world, so safety is partly covered; the description adds the crucial two-step behavior (first call only previews items and markup, repeat with confirm_token to actually create and publish). That is real context beyond the annotations, though it does not say whether the publish step is reversible or required permissions.

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

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

One compact sentence front-loads the core transformation, then the two-mode behavior, with no filler. Every clause carries information an agent needs.

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 present, return values need no explanation, and the preview/confirm flow plus publish side effect are disclosed. Still, for a destructive 7-parameter mutation, it omits what the preview returns, whether the publish can be undone (undo_list_change exists), and the role of import/list.

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

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

Schema coverage is 57%; selector, fields and path are documented in the schema, and the description adds the meaning of confirm_token (triggering creation rather than preview). But list, import and site get no explanation in either place, so it does not fully compensate for the coverage gap.

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

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

States a specific verb and outcome: turns repeated blocks (a menu) on a page into a list, and names the exact input shape (repeated blocks). The two-phase preview/confirm behavior further distinguishes it from list-creation siblings like save_list or add_list_items.

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 it applies (only when content is repeated blocks such as a menu) and explains the confirm_token sequence, which is useful usage context. However, it never explicitly contrasts with add_list_items, import_list_items, or save_list, so an agent must infer which list tool to pick.

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

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

Annotations already declare destructiveHint=true, openWorldHint=true and non-idempotent, so the safety profile is covered structurally. The description adds genuinely new context: a confirmation flow where 'confirm: true returns approve_url'. It omits what happens without confirmation, what approve_url is for, and how confirm_token is obtained.

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

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

A single dense sentence that front-loads the listing behavior before the restore action. Nothing is padding, though the parenthetical about approve_url is slightly buried at the end where it matters most.

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?

An output schema exists, so return values need not be explained. Given five parameters and a destructive, open-world mutation, the description covers the essential scenario and the confirmation mechanism; the remaining gaps (decline semantics, token sourcing) are real but secondary for a correct first call.

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

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

Schema description coverage is 0%, so the description must carry the load. It explains 'confirm' and implies 'sites' (the chosen ones), but leaves 'decline', 'confirm_token' and 'workspace' entirely undocumented in both schema and text.

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

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

The description names both a list operation and a restore operation on 'sites that left a workspace', which is more specific than the title but conflates two behaviors into one tool. It never states which sibling to use instead (move_sites, transfer_site, get_site), so the boundary is only inferrable from the frozen-workspace scenario.

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

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

It gives a triggering condition ('when it froze' / 'once it is paid again'), which implies when the tool applies. But it never says when not to use it, and it doesn't tell the agent to call it once to list versus again to restore.

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

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

Annotations already declare the destructive, non-idempotent, open-world profile, so the bar is lower; the description still adds real context — that cancellation is a two-step flow that emails the customer, one email per action, and that a paid booking is refunded in full by default. It stops short of spelling out irreversibility or permission requirements, but the side effects are well disclosed.

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?

Dense and front-loaded — the core action and its two branches lead, with consequences trailing. The trailing '(approve_url)' is cryptic and slightly muddies the close, keeping it from a 5.

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

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

For a destructive, non-idempotent mutation with 8 params, the description covers the consequences an agent most needs (email side effect, refund policy, two-step flow), and an output schema exists so return values needn't be explained. Minor gaps remain around series scope and the confirm_token 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 63%, and the description compensates for the biggest gap by explaining that item_id accepts either a waitlist wl_ id or a class cl_ id and what each does. It also confirms the refund default, though it leaves series, message, plugin_id, and confirm_token unaddressed 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?

States a specific verb and resource ('Cancels a booking or declines a request') and immediately qualifies the resource variants: a wl_ entry_id removes a waitlist person, a cl_ class_id cancels the class. That level of specificity lets an agent distinguish this from edit_booking or approve_booking without opening a schema.

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

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

The description gives conditional behavior tied to item_id prefixes, which implicitly tells the agent which mode applies, but it never names an alternative tool or states when to prefer approve_booking, refuse_order, or edit_booking instead. Usage is inferable rather than explicit.

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

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

Annotations already declare destructiveHint=true and idempotentHint=true. The description adds useful behavioral context beyond those flags: the recipient's link stops working and the site itself is unchanged, clarifying the scope of the destructive effect.

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

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

The description is a single efficient sentence that front-loads the operation and then states the effect. Every clause adds useful information with no filler.

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

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

For a simple one-parameter tool with an output schema and rich annotations, the description provides the key operational context and effect. The main remaining gap is input parameter format, which is a minor deficiency rather than a fundamental omission.

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

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

There is one required parameter ('site') with 0% schema description coverage, so the description must compensate but does not. It does not explain whether 'site' expects an ID, domain, or name, leaving the input format ambiguous.

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

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

The description names a specific verb and resource ('Cancels a site's pending transfer') and implicitly distinguishes itself from sibling 'transfer_site'. It also states the target condition ('pending transfer'), so an agent can identify the operation without opening the schema.

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 is clear from the phrase 'pending transfer', which indicates the applicable state, and the effect clarifies the intended operation. It does not explicitly name alternatives such as transfer_site or state when not to use it, but the context is sufficiently clear for selection.

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

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

Annotations already establish that this is a safe, idempotent, read-only operation, so the description's added value is the output contract: severity ordering, per-problem pages/why/fix, and a readable checklist. What it omits is operational behaviour — that it fetches the live site (latency, possible failures) and when site_token is required for anonymous deploys.

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

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

A single tight sentence that front-loads the verb and resource, then enumerates the output shape without filler. Every clause carries information an agent needs to decide to call it.

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 output schema exists, so return values needn't be re-explained, and the description is adequate on scope. It is still thin for a live-site fetch: no note about cost/latency, authentication via site_token, or how a single-page path interacts with the area-based scan.

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 75%, so the schema largely documents the parameters. 'Measured problems by area' loosely ties to the areas enum list, but the description adds no meaning for path (single-page scoping) or site_token (secret for anonymous deploys) beyond what the schema already states — the baseline 3 applies.

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

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

Specific verb+resource ('Checks a live site') followed by a precise account of the returned artifact: problems by area, severity-ordered, with pages, rationale and fix, plus a checklist. This clearly separates it from retrieval siblings like get_site or get_analytics, though it never names a sibling explicitly.

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

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

Usage is implied by 'live site' and 'checklist to judge by reading', suggesting an audit of a deployed site rather than stored metadata. There is no explicit when-to-use/when-not statement and no pointer to alternatives such as get_site or get_analytics for plain data retrieval.

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

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

Beyond the destructive and open-world annotations, it discloses the 1-hour link expiry, immediate publishing as a new version, and that replace_site uses a zip that replaces every file. These are important behavioral consequences that help the agent reason about destructive scope and timing.

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 core behavior, expiry, immediate-version effect, and replace_site caveat are front-loaded and waste no words. The parenthetical get_site reference earns its place by clarifying where uploaded versions appear.

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 annotations declaring destructive/open-world behavior, an output schema, and strong schema descriptions, the description supplies the remaining context an agent needs: timing, immediate versioning, and the replace_site condition. No essential decision information is missing.

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

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

The schema already covers 75% of parameters, and the description adds useful meaning for replace_site and its relationship to folder behavior. It does not explain site_token, but that parameter is documented in the schema, so the description adds value without needing to duplicate everything.

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

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

The description states a specific resource and action: a 1-hour link for uploading photos/files into a site folder, with a distinct replace_site mode. It clearly distinguishes upload-link behavior from listing via get_site and from whole-site replacement, so an agent can identify the tool without opening the schema.

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

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

It gives an explicit conditional rule for replace_site: use it only when the user asks. It also implies the default upload-link use case and references get_site for listing versions, though it does not enumerate other alternatives beyond the two modes.

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

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

The annotations already mark this as destructive and non-idempotent. The description adds useful context that deleting a list also deletes its items, implying a cascade, but it does not explain the confirm_token, irreversibility, or required permissions.

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

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

It is a single front-loaded sentence with no wasted text. The parenthetical is awkward, but the core destructive action is stated immediately.

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

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

For a destructive tool with an undocumented confirm_token and zero parameter descriptions, the description is too sparse. The output schema means return values need not be explained, but safety and parameter requirements are missing.

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

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

Schema description coverage is 0%, and the description does not explain any of the three parameters. It does not clarify what 'site' or 'list' should contain, and it completely omits the presence and purpose of 'confirm_token'.

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

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

The description states a clear verb and resource: it deletes a list and its items. That distinguishes it from save_list and remove_list_items, though it does not explicitly name those 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?

It gives no guidance on when to use this tool versus remove_list_items, undo_list_change, or save_list. The parenthetical '(a list with items: two steps)' is cryptic and does not clarify the usage context.

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

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

Annotations already declare destructiveHint=true, openWorldHint=true, and readOnlyHint=false, so the safety profile is covered. The description adds genuinely new behavioral context: deletion is permanent and requires an approve_url/confirm_token confirmation round-trip. The second sentence is grammatically unclear, which keeps it from a 5.

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 definition is short, but the second sentence ('Again with confirm_token: its status.') is cryptic and poorly structured. It is concise without being clear, which is a structural flaw rather than excess length.

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

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

An output schema exists, so return values need not be explained in depth, and the annotations cover the destructive profile. Still, for a destructive open-world tool with low schema coverage, the description should more clearly explain the confirmation flow, site_token usage, and what happens on a failed or missing confirmation.

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 33%, so the description must carry more weight. It partially explains confirm_token (used on a second call to get status) and implies the 'site' value is the site address typed by the user, but it never mentions site_token, which is documented only in the schema.

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

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

The description states a specific verb and resource ('Deletes a site permanently'), and the word 'permanently' signals scope beyond a generic delete. It does not explicitly contrast with the sibling 'bring_back_sites', so it stops short of a 5.

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

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

It implies a two-step procedure: first call returns approve_url for the user to type the site address, then call again with confirm_token to get status. However, it never states when to choose this tool over alternatives or what prerequisites must be met before starting the flow.

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

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

Annotations already declare destructiveHint=true, openWorldHint=true, and idempotentHint=false, so safety burden is partly covered. The description adds behavioral context by implying that an update requires base_revision (a concurrency guard) and that patch mode needs deleted paths, but it never states that publishing overwrites the live site, how conflicts are handled, or what preview/staging do. It does not contradict 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?

Two sentences, front-loaded with the core action, and zero filler. The telegraphic 'New: ... Update: ...' phrasing is dense but readable, though a couple of fragments are cryptic enough to cost a point.

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 12-parameter destructive publish tool with an output schema present, the description covers the mode selection that actually determines whether a call succeeds. The remaining gaps (auth requirements, conflict semantics on base_revision mismatch) are genuine but modest given annotations and an output schema. If strict, a 4 could be argued, but the mode routing is the load-bearing information and it is present.

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 12 parameters and only 67% schema coverage, the description earns credit for tying parameters into coherent bundles ('Update: site and base_revision', 'patch: true with changed files and deleted paths'), which the schema does not express. It leaves patch/preview/staging/workspace/site_token/confirm_token relationships largely unexplained, so it is not a 5.

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

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

States a specific verb and resource ('Publishes a new static site or version') and splits the operation into New vs Update modes, which is more precise than the title 'Publish site'. It does not name any sibling (rollback, list_versions, delete_site) to differentiate itself, so it falls short of a 5.

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

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

Gives explicit conditional guidance for choosing between invocation modes: 'New: every file, or a template' and 'Update: site and base_revision with every file, or patch: true with changed files and deleted paths.' That is real when-to-use guidance, but it is scoped to internal modes and says nothing about when to prefer this over rollback, preview_as_user, or list_versions.

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

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

Annotations already declare destructiveHint=true, idempotentHint=false, openWorldHint=true. On top of that the description discloses the two-step confirm_token confirmation flow for moves/emailing changes and the clash-override behavior of force:true, which are meaningful behavioral facts not in the annotations or schema.

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

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

Three front-loaded sentences covering the main purpose first, then edge cases. Extremely dense but nearly every clause carries information; only the compressed phrasing of the confirm_token sentence borders on cryptic.

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 and annotations are rich, lowering the burden, and the description handles the tricky interactions. But for a 16-parameter mutation tool with 44% schema coverage, several parameters still lack any documented semantics, leaving the definition short of complete.

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

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

Schema coverage is only 44%, so the description must compensate. It adds real meaning for item_id's cl_ convention, the start+resource pairing, confirm_token, and force, but leaves customer-detail fields (name, email, phone, notes, party, site) unexplained, so compensation is partial.

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

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

States a specific verb and resource ('Changes one booking') and enumerates what can change: customer details, or start+resource to move. It also disambiguates item_id (a cl_ prefix means a class). Sibling routing (vs add_booking, cancel_booking, set_booking_outcome) is implied but never named.

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

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

The description gives invocation-level guidance for tricky parameters ('A move or a change that emails someone asks first (confirm_token); force: true books a clash'), which is real when-to-use context. However, it does not state when to choose this over cancel_booking or set_booking_outcome, leaving the main routing decision to inference.

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 important behavior beyond the annotations: it returns approve_url and nothing is sent until the Site Owner approves. This approval workflow is valuable context. The only gap is that it does not reconcile the draft-only behavior with the destructiveHint annotation or explain permissions beyond Site Owner approval.

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 no wasted text. The scope and approval constraint are stated immediately.

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

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

The presence of an output schema means return values need not be fully explained, and the annotations cover the safety profile. Still, for a 5-parameter mutation-style tool with low schema coverage, the description should explain the confirm_token and site parameters more fully to be complete.

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

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

Schema description coverage is only 40%, so the description should compensate. It clarifies that plan can mean all users or one plan, but it leaves site, subject, and especially confirm_token unexplained, even though confirm_token is likely central to the approval flow.

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

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

The description states a specific verb and resource: drafts an email to the app's users, with scope limited to all users or one plan. This is clear and specific enough for an agent to distinguish it from unrelated sibling tools such as invite_users or remove_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?

It indicates that the tool creates a draft and that sending requires Site Owner approval, which is useful usage context. However, it does not explain when to choose this over alternatives, nor does it mention prerequisites 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 annotations already flag the operation as non-read-only, non-idempotent, open-world, and destructive, but the description adds substantial behavioral detail beyond that: the result is emailed to the owner, the link is one-use and valid for 24 hours, the archive contains CSV and files, and the link is not returned through this tool.

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

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

The description is a single dense sentence that front-loads the action and outcome. Every clause adds useful information: delivery method, link lifetime, archive contents, scope, authentication, and the fact that the link is not returned here.

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, the description does not need to document return values. Annotations cover the safety profile, and the description covers delivery, link validity, contents, and scope. The main gap is the unexplained required 'site' parameter, but otherwise the definition is rich enough to call 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 0%, so the description must compensate for both parameters. It explains the optional 'list' scope ('one list or all') but does not explain the required 'site' parameter at all. With only half of the small parameter set clarified, the description leaves a meaningful gap.

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

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

The description states a specific verb and outcome: emails the owner a one-use link to a zip export of one list or all. It clearly distinguishes this tool from direct data retrieval siblings like get_app_data by emphasizing the emailed link and the fact that the link never comes back through this tool.

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

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

It gives an implicit use case (requesting an emailed export link) and a prerequisite ('signed in only'), but it does not explicitly say when to use this instead of get_app_data, create_upload_link, or other export-related siblings. The agent can infer the intended use, but alternatives are not addressed.

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

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

The description adds crucial operational context beyond the annotations. Mentioning that the results are 'with copies shown on the site' and that it functions as a 'privacy request' adds necessary behavioral context for the agent.

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 and efficiently communicates the tool's main function and constraints in a single, well-structured sentence.

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

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

While the tool is clearly defined as read-only, it is not contextually complete for an AI agent because it fails to clarify how the filtering parameters (site, scope) affect the output or the search behavior. The low parameter coverage requires the description to do more work than it does.

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 having 5 parameters defined in the schema, the description only mentions the primary identifier ('email'). Given the low schema description coverage (20%), the description fails to provide any semantic meaning or context for the filtering parameters like 'site', 'scope', 'limit', or 'cursor'.

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: finding records based on an email address. It distinguishes its scope by specifying that this is related to a 'privacy request,' which helps differentiate it from general record retrieval 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?

It provides helpful constraints regarding the tool's scope by noting that functions like 'Export and erase' are explicitly handled by the dedicated application, guiding the agent toward correct tool selection for mutation tasks.

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

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

The annotations already declare a destructive, non-idempotent, open-world write operation. The description adds useful context by naming the external side effect (emails the customer) and the optional note, though it does not explain irreversibility or the meaning of the two-step/confirm_token flow.

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 definition is a single front-loaded sentence with no wasted words. The parenthetical '(two steps)' is slightly cryptic without follow-up, but the overall brevity is appropriate.

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 presence of an output schema and rich annotations reduces what the description must cover. However, for a destructive five-parameter mutation with 20% schema coverage, the description leaves important gaps around confirm_token and the required identifiers.

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 20%, so the description should compensate for undocumented parameters. It mentions only the optional note, which the schema already describes, and leaves site, plugin_id, item_id, and especially confirm_token unexplained.

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

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

The description states a specific verb and resource: it marks an order sent and emails the customer. That is clearly distinguishable from sibling operations like refund_order and refuse_order, though it does not explicitly route the agent away from those 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?

It implies the tool is for fulfilling an order, but gives no explicit guidance on when to use it versus refund_order, refuse_order, or other order-related siblings. There are no stated preconditions, exclusions, or alternative-selection rules.

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

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

Annotations already declare readOnly, idempotent, non-destructive, and closed-world, so the safety profile is fully covered. The description adds one genuinely new fact, that sites are returned 20 at a time and are searchable, but says nothing about the cursor round-trip or what 'notices' and 'new-item counts' actually contain.

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

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

One sentence, front-loaded with the verb and resource, with the payload list packed into parenthetical groups. No filler, though the comma-separated enumeration is dense and slightly hard to scan.

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

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

With a rich output schema and full param coverage, the description does not need to explain return values, and it doesn't. What is missing is routing context, i.e. why an agent would pick this over the many narrower sibling getters, which matters for a tool whose payload overlaps several of them.

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%, documenting `include` values, `sites_limit` default 20, `sites_query` filter fields, and `sites_cursor`. The description's '20 at a time, searchable' merely restates the limit and query params without adding format or interaction detail, so the baseline 3 applies.

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

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

States a specific verb and resource ('Returns the signed-in account') and enumerates the payload sections (plan, workspaces, sites, notices, counts, programs). It is clearly distinguishable from single-resource siblings like get_site or get_domains, though it never names those 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?

No guidance on when to call this versus get_site, get_activity, or get_domains, and no signal about when the extra `include` sections are worth requesting. The agent must infer that this is the 'everything about my account' entry point.

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

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

Annotations already cover read-only/idempotent/non-destructive safety. The description adds real context beyond them: newest-first ordering and role-based visibility (Owner sees all, Admin all but billing, others only their own) plus the paid-plan prerequisite.

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 dense, front-loaded sentences with no filler; the scope/permission detail follows the core purpose. Slightly compressed ('who did what ... where and when') but readable.

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

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

For a read-only log tool with annotations and an output schema, the description supplies the key non-schema facts: ordering, event categories, and per-role visibility. Remaining gaps (site/person filter semantics) are covered by the schema.

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 67% with an output schema present. The description usefully maps the `type` enum categories (publishing, rollbacks, people, domains, settings, protection, visitor data, AI apps, billing) and the newest-first ordering clarifies how `before` pagination works, adding 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?

States a specific verb+resource ('Returns the activity log') and enumerates the event categories it covers, so an agent knows this is the audit/event feed rather than analytics. No explicit distinction from siblings like get_analytics, keeping it below a 5.

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

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

The description explains access scoping (personal paid account vs. workspace roles) which implies when results differ, but it gives no explicit when-to-use-this-vs-alternatives guidance or exclusions.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the safety profile is covered. The description adds genuinely non-obvious behavioral context: the data is cookieless, retention is limited by plan ('for the days the plan keeps'), some metrics are paid-plan-only, and taps outside the UK are excluded (taps_not_counted). These are real caveats that affect interpretation of results.

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

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

Two sentences, front-loaded with the headline result and then the metric inventory and the caveats. The nested parenthetical is dense but every element (metrics, plan gating, UK exclusion) carries information. Slightly heavy in one clause, so a 4 rather than a 5.

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?

An output schema exists, so the description need not explain return values; it instead spends its budget on data limitations and plan gating, which is the right choice for a 4-param read tool. Minor gap: it never mentions the required `site` parameter or the default 7-day window, leaving those entirely to the schema.

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 75% schema coverage the schema documents days, recent, and compare. The description still adds meaning by tying the `days` window to plan retention limits and by marking the extra metrics (and implicitly `compare`) as paid-plan features. It does not restate the `site` or `recent` semantics, which the schema already handles.

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

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

Specific verb ('Returns') plus resource ('cookieless visitor numbers') with an explicit enumeration of the metrics returned (views, visitors, contacts, and paid-plan extras). It clearly describes the output domain. It does not explicitly differentiate from the closest sibling, find_visitor_records, so it stops short of a 5.

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

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

The description never states when to use this tool versus alternatives such as find_visitor_records or get_activity, nor any prerequisites. The only contextual hint is the parenthetical retention phrase 'for the days the plan keeps', which implies a data-availability constraint but is not framed as 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?

Annotations already declare this a safe, idempotent, closed-world read, so the bar is lower. The description still adds real value by noting the diagnostic behavior of check=true and that the "needs attention" section is counts-only, but it omits that check=true is a heavier scan and doesn't clarify the odd const-true constraint.

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

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

A single dense sentence front-loads the resource and then lists return contents with no filler. It reads as a run-on, with the check clause tacked on the end, but nothing is wasted.

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?

An output schema exists, so return values needn't be described, and annotations cover the safety profile. Given a two-parameter read tool, the description supplies the payload overview and the check behavior — the only real gap is `site` format, which keeps this from being flawless but is minor in context.

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

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

Schema description coverage is 0%, so the description carries the full burden. It gives partial meaning for `check` (checks pages and settings) but says nothing about the required `site` parameter — no expected format (subdomain, ID, or domain) — and never explains why `check` is constrained to the literal true rather than a boolean flag.

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

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

States a specific verb and resource ("Reads a site's app") and enumerates the payload (on/off, sign-up, path, plans, user counts, lists with row counts), so an agent knows exactly what comes back. It does not differentiate itself from close siblings such as get_site, get_app_data, or check_site, and the embedded check semantics overlap with check_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?

Usage is only implied: "check: true checks pages and settings" hints at when to enable the extra scan, but there is no statement of when to call this versus get_site, get_app_data, or check_site, and no prerequisites or exclusions. An agent must infer selection from the payload list.

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

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

Annotations already declare readOnly, idempotent, and non-destructive behavior. The description adds valuable context beyond them: pagination is 50 per call with a 'next' mechanism, an owner-opt-in requirement, and a warning that user text is untrusted. It does not cover error behavior or full rate limits.

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

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

The text is very short and front-loads the main resource, but it is telegraphic and fragmented ('next' is ambiguous). For an 11-parameter tool it is under-specified rather than appropriately sized.

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?

An output schema exists, so return formatting needn't be explained, and annotations cover safety. However, with 11 parameters and no schema descriptions, the description leaves most parameters undocumented and the tool's usage contexts incomplete.

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

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

Schema description coverage is 0% across 11 parameters, so the description must carry the burden. It explains only members, item_id, file_id, and vaguely the list parameter; site, group, query, since, cursor, member, and status receive no explanation at all.

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

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

The description names the resource (users' entries of a list) and distinguishes several modes: list entries, members: true, item_id for a single entry with comments, and file_id for a file. It is specific about what gets returned, though it never contrasts the tool with siblings like get_lists or export_app_data.

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

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

It provides a prerequisite ('Needs the owner's opt-in') and hints at modes, but gives no guidance on when to choose this tool over alternatives such as get_lists or export_app_data. The agent is left to infer the selection 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 readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description still adds real value by disclosing that pending domains are re-checked live (latency/side-effect nuance) and that no domain can actually be purchased here. It says nothing about result limits or what an empty lookup returns.

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

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

A single dense sentence with zero filler, front-loaded with the object of the operation before the two mode branches. The telegraphic 'with site, the ones on it' phrasing is efficient but slightly clipped.

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?

An output schema exists, so return values need no explanation, and the description still flags status and DNS records as payload. For a three-param, no-required-param read tool this is nearly sufficient; only the tlds interaction and multi-param combination behavior are left open.

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 gives meaning to 'site' (which the schema leaves undocumented) and to 'query'. However it never mentions 'tlds', the third parameter, so the agent must infer from the schema that it only applies alongside 'query' and what happens if both 'site' and 'query' are supplied. With 67% schema coverage this is roughly baseline.

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

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

States a specific verb and resource ('Lists custom domains') and immediately splits the tool into its two distinct modes, tied to the 'site' and 'query' parameters. An agent can tell this apart from the mutation siblings add_domain/remove_domain without opening any schema.

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 routes the agent: pass 'site' to inspect domains already on a site, pass 'query' to discover names available to buy. The parenthetical '(Page Lemon sells none)' heads off a wrong assumption about purchasing. It does not name the mutation siblings it should be paired with when the intent is to add or remove.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description still adds real behavioral value beyond them: 'as customers see them' signals that returned slots respect customer-facing booking rules rather than an admin view, and the default-date behavior is not encoded anywhere in the schema. Remaining gaps (timezone, whether slots are live, result granularity) are partly mitigated by the output schema.

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

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

A single front-loaded sentence with the verb and scope first and the default behavior parenthetically appended. No filler, nothing redundant with the title.

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 output schema and annotations remove the burden of describing return values and safety, and the core query is explained. But for a six-parameter tool, the required 'site' parameter is never mentioned and the party/resource filters — which materially alter availability — are left completely unexplained, leaving the agent to infer their effect.

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

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

Schema coverage is only 50%: site, party, resource and plugin_id carry no descriptions. The description only speaks to service and date, and never explains that party size or resource (staff/room) meaningfully change which slots are returned — the most important semantic for an availability query. It does not compensate for the gaps the schema leaves.

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

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

The description states a specific verb and resource ('Finds the free booking times') scoped to a service and a date, which is far more precise than the title alone. It implicitly distinguishes itself from the mutation siblings (add_booking, edit_booking, cancel_booking) by being the read-side availability lookup, though it never names an alternative explicitly.

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

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

The parenthetical '(default: the first with any)' explains what happens when date is omitted, which is useful usage guidance. However, there is no statement of when to prefer this tool over a direct booking attempt, no prerequisite context (e.g. check availability before calling add_booking), and no guidance on when to pass party or resource filters.

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

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

Annotations already cover safety (readOnly, idempotent, non-destructive), so the bar is lower, and the description still adds two real behavioral traits: entity visibility ('shown on its pages' vs 'private') and 'Marks nothing read', which tells the agent this read has no side effects on form-reply status, distinguishing it from mark_form_replies. Pagination and filtering behavior are still undisclosed.

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?

It is short and front-loads the resource, but the sentence-fragment style ('No site: counts for every site.', 'Marks nothing read.') sacrifices parseability for brevity. For an 18-parameter polymorphic tool it is under-specified rather than efficiently concise.

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?

An output schema exists, so return shape needn't be explained, but the tool has 18 optional parameters and multiple modes, and the description omits pagination, filtering (where/view/q), export formats, and how mode interacts with scope. An agent could not reliably compose a valid call from this text alone.

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 56%, so the schema documents roughly half the parameters and the description must carry more weight. It adds meaning for site, list, and scope ('No site: all, personal, workspace:<id>' pattern) and ties status/state to form replies and bookings, but says nothing about q, where, sum, expand, export, limit/cursor, or service/resource, leaving roughly a dozen parameters semantically thin.

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 does state the resource (lists, form replies, bookings) and encodes three distinct modes: no site -> per-site counts, site -> that site's lists, list -> its items. However, the telegraphic phrasing ('Reads Lists: a site's lists (menu, team; shown on its pages)') forces the agent to decode intent, and no sibling is named or excluded (e.g. get_site, export_app_data, save_list).

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 provides mode-selection conditions ('No site: counts for every site', 'With list: its items, filtered'), which is genuine routing guidance for a polymorphic tool. But it never states when to prefer this over overlapping siblings, and prerequisites or required parameter combinations per mode are left implicit.

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

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

Annotations already establish that this is a read-only, idempotent, non-destructive operation. The description adds useful context such as files being returned 200 at a time and older copies being available via as_of/version, but it does not explain pagination via cursor or other operational behavior beyond what the 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 compact sentence with front-loaded purpose and semicolon-separated clauses for the main modes. There is essentially no wasted text.

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

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

An output schema exists, so return values need not be explained, and annotations cover safety. Still, for a 10-parameter read tool with only 60% schema description coverage, the description leaves important operational concepts such as cursor-based pagination, prefix, and staging unclear, so it is only partially 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 60%, and the description adds some meaning for path, paths, as_of, version, and site_token. However, several parameters, notably cursor, prefix, staging, and the required site parameter, receive no useful semantic explanation in either the description or schema, leaving notable gaps.

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

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

The description gives a specific verb and resource: it “reads a site” and enumerates status, files, single-file mode, multi-file mode, older copies, and claim status. This is clear enough for an agent to know what the tool does, though it does not explicitly distinguish itself from nearby siblings such as check_site or list_versions.

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

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

It explains mode selection within the tool — path for one file, paths for several, as_of/version for older copies, site_token for claimed status. However, it gives no guidance on when to use this tool instead of alternatives like check_site or list_versions, and includes no exclusions.

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

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

Annotations already declare destructive=true, openWorld=true, and non-idempotency. The description adds important behavioral context beyond annotations: the first call is a preview, and confirm_token commits the import as one change, which partially mitigates the destructive profile.

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 with no wasted words. It conveys purpose and the most important two-phase behavior immediately.

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

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

The output schema and annotations carry return values and safety signals, and the description covers the essential preview/confirm flow. Still, for a destructive six-parameter import tool, key parameters such as site, list, and create_missing remain unexplained, leaving meaningful gaps.

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

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

With 50% schema description coverage, the description clarifies that csv and rows are alternative input formats and that confirm_token switches from preview to save. It does not explain site, list, or create_missing, so it only partially compensates for the schema gaps.

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

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

The description states a specific verb and resource: 'Imports CSV or rows into a list.' This clearly distinguishes bulk import from sibling tools like add_list_items or update_list_items, though it does not explicitly name 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?

It explains the two-step preview/confirm workflow, which is useful invocation guidance. However, it does not say when to use this tool instead of add_list_items, update_list_items, or save_list, so usage is implied rather than fully framed.

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 flag destructive=true, non-idempotent, open-world. The description adds real behavioral context beyond them: a 50-recipient cap per call, that invitation emails are dispatched, that it can serve as approval for pending join requests, and the three result buckets returned. It does not mention permission/authorization requirements, which keeps it from a 5.

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 compact clauses with the core action front-loaded and no filler; the 50-item cap and return buckets each earn their space. Slightly terse to the point of leaving key parameters unaddressed, but structurally sound.

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?

An output schema exists, so return-value detail is optional and the brief 'returns invited, already and refused' is a bonus. However, for a destructive, non-idempotent mutation with 4 params at 25% coverage, the missing explanation of site, emails, and especially confirm_token leaves an agent under-informed about correct invocation.

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

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

Schema description coverage is only 25%: site and emails are undocumented, and confirm_token — an unexplained, behaviorally significant parameter for a mutation — is never addressed in the description either. Only 'plan' is documented, and only in the schema. The description does not compensate for the coverage gap.

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

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

Names a specific verb and resource (invite people to a site's app) and adds scope detail (up to 50 per call, invitation email sent). It does not differentiate itself from the close sibling add_people or email_users, which could plausibly overlap, so it falls short of a 5.

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

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

The one usage-like statement — naming someone who asked to join approves them in two steps — is genuinely useful context about an alternate effect. But there is no explicit guidance on when to prefer this over add_people or email_users, and no prerequisites or exclusions stated.

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 destructive=true and readOnly=false, so the safety profile is covered. The description adds meaningful behavior beyond annotations: the workspace freezes 14 days after the plan ends, and confirm: true returns approve_url. It still omits auth requirements and does not explicitly discuss irreversibility, but it adds solid operational 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 short and front-loads the purpose before the confirm behavior. The phrase 'Without confirm: the questions' is terse to the point of ambiguity, but overall there is little wasted text.

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

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

For a destructive tool with 7 parameters and no schema descriptions, the definition leaves substantial gaps: it does not adequately explain the parameters or the distinction between take, offer, keep_editors, and confirm_token. The output schema reduces the need to explain return values, and the freeze/confirm notes help, but the parameter documentation is not complete enough for confident invocation.

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

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

Schema description coverage is 0% with 7 parameters, so the description must carry the burden of explaining them. It gestures at concepts such as site migration, editor retention, bookings, and confirm, but does not map those concepts to the actual parameter names take, offer, keep_editors, confirm_token, or workspace clearly enough for reliable use.

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 identifies the resource and action: preparing to end a workspace plan, including site migration, editor retention, bookings, and the post-plan freeze. It does not explicitly differentiate this tool from siblings such as save_plan, move_sites, or transfer_site, so it stops short of a 5.

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

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

It explains a two-step confirm flow: call without confirm to get questions, then use confirm: true to receive approve_url. That is useful invocation guidance, but it does not state when to choose this tool over 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds value by naming what the listing surfaces (roles, pending invites, pending transfer, protection), but says nothing about access requirements for the call or how large result sets are handled.

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

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

One sentence, front-loaded with the verb and resource, with the enumeration of contents following. Slightly list-heavy but no wasted clauses.

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?

An output schema exists, so return shape needn't be described, and the tool is low complexity with one parameter. The remaining gap is the site identifier format and any prerequisite access level, which the description leaves unaddressed.

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

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

Schema description coverage is 0% and the description does not explain what form the 'site' value takes (ID vs. domain vs. workspace-qualified name), which is the one thing an agent could get wrong here. With a single undocumented required parameter, the description had the burden and did not carry it.

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

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

States a specific verb (lists) and resource (who has access to a site) and enumerates the contents: roles, pending invites, users, pending transfer, protection. That distinguishes it from sibling mutations like add_people, remove_people, and invite_users, though it never names those siblings explicitly.

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

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

There is no when-to-use guidance and no mention of alternatives such as get_site, invite_users, or remove_people. An agent must infer from the verb 'lists' that this is the read path and the others are the write paths.

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, destructiveHint=false and openWorldHint=false, so safety is covered. The description adds mode-dependent behavior and enumerates return contents for the plugin_id case, but does not discuss pagination, limits, or permissions; with an output schema present, the return-field list adds less unique value.

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

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

The description is a single front-loaded sentence that conveys several modes efficiently. The semicolon-separated clauses are dense but each carries meaningful information.

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

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

Given annotations covering safety and an existing output schema, the description supplies the main missing context: the three query modes and the richer return shape when plugin_id is supplied. Minor gaps around pagination or auth are acceptable here.

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

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

Schema coverage is only 33%, with site and plugin_id undocumented in the schema. The description compensates well for those two parameters by explaining what omitting site does and what plugin_id retrieves; lang is left to the schema, which does document it.

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

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

States a specific verb and resource (lists plugins) and distinguishes modes by site/plugin_id. It does not explicitly contrast with siblings like add_plugin or update_plugin, but the purpose is clear from the description alone.

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 parameter-driven modes (no site = per-site listing, plugin_id = full detail) which implies when each form is useful. It does not say when to use this versus alternatives such as update_plugin or remove_plugin, so guidance remains implicit.

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

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

Annotations already cover safety traits: readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false. The description adds useful behavioral context beyond annotations: newest-first ordering, a page size of 200, and which fields are returned. It stops short of explaining authentication or pagination continuation behavior.

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

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

The description is a single front-loaded sentence with no wasted words. It puts the core action first, then adds ordering, pagination, and return-field detail 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?

This is a simple read-only listing tool with rich annotations and an output schema, so the description does not need to explain return values in depth. It is nearly complete, though it omits how the optional filters and pagination are meant to be used.

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

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

Schema description coverage is 67%, so the schema carries most parameter meaning for 'by', 'since', 'before', and 'site_token'. The description adds no filter semantics beyond the implicit site scope, and 'since_days' plus the required 'site' parameter remain undocumented in both places.

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 gives a specific verb and resource: 'Lists a site's versions,' and adds scope, ordering, and returned fields. It is clear what the tool does, but it does not explicitly distinguish itself from the related sibling rollback tool.

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

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

The description explains what the tool returns but gives no explicit guidance on when to use it versus alternatives such as rollback. There are no stated exclusions, prerequisites, or workflows.

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

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

Annotations already declare destructiveHint=true and idempotentHint=true, so the safety profile is known. The description adds the critical detail that 'bin' means deletion after 30 days, which annotations do not convey, giving an agent real consequence information before calling.

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 short, but it is a dense semicolon chain that is hard to parse. The first sentence is front-loaded with the core action, but the second sentence crams several conditional behaviors into one run-on clause.

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?

An output schema and annotations cover return values and safety, and the description supplies the 30-day deletion note. It still leaves ambiguity about parameter combinations, such as whether item_ids are required for all mark values and how plugin_id relates, so an agent may hesitate on edge cases.

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

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

Schema description coverage is 80%, so the schema already documents most parameters. The description adds combinational semantics such as 'with mark read, also account notice ids' and 'all: every notice, or every new form reply', but these are terse and partially redundant with the enum 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 first clause states a specific verb and resource ('Marks form replies or bookings'), but the scope quickly expands to notices, orders, and account notice ids, making the actual domain muddled. An agent can infer it is a bulk-marking tool, but the jargon ('mark', 'bin', 'nt_…') obscures the precise purpose.

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

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

The phrase 'only when the user asks' gives one explicit guardrail, and the description implies use with specific mark values. However, it names no alternatives and does not state when not to use this versus other mutation tools.

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

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

The annotations already mark this as destructive, open-world, and non-idempotent, and the description adds important behavioral detail: the two-step confirmation flow and the immediate access loss for Site Developers who are not invited. It does not cover auth or rate-limit behavior, but it does disclose the key destructive consequence beyond 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 three sentences and front-loads the core action before explaining the confirmation flow and access-loss warning. The phrasing around 'Without confirm: the questions...' is somewhat compressed, but there is little wasted text.

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

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

For a complex 8-parameter destructive tool, it covers purpose, confirmation behavior, and the critical access-loss effect, and an output schema exists. Still, the low schema coverage and absence of alternative guidance or parameter explanations leave meaningful gaps for safe invocation.

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

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

With 8 parameters and only 25% schema description coverage, the description must compensate but largely does not. It mentions confirm: true and implies people/sites handling, but leaves mode, plan, personal_plan, confirm_token, workspace, and site-selection semantics unexplained.

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

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

The description states a specific verb and resource: it moves personal sites and their Site Developers into a paid workspace. The scope is clear enough to distinguish it from generic site operations, but it does not name related siblings like transfer_site or bring_back_sites.

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

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

It gives procedural guidance for the confirmation flow: without confirm it returns questions, a recommendation, and move_url, then confirm: true uses approve_url. However, it does not say when to choose this tool over alternatives such as transfer_site or bring_back_sites, nor does it state prerequisites.

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

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

Annotations already declare the mutation profile (readOnlyHint false, destructiveHint false), but the description adds meaningful behavior beyond them: the test user is one-hour, is never counted, and its rows and files are deleted afterward. It does not cover permissions or rate limits, but the ephemeral lifecycle and cleanup are well disclosed.

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

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

A single efficiently structured sentence that front-loads the action and uses a concise parenthetical for the important lifecycle caveats. No sentence is wasted.

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?

An output schema exists, so the return value needn't be fully explained, but the description still helpfully names signin_url. However, for a two-parameter tool with 0% schema description coverage, the missing meaning of 'site' and 'plan' leaves a meaningful gap.

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

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

There are two parameters with 0% schema description coverage, so the description carries the full burden of explaining them. It does not define what 'site' identifies or what 'plan' controls; it only describes the tool's overall effect.

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

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

States a specific verb and resource ('Makes a one-hour test user') plus the outcome ('returns signin_url to see the app as a user'). It is clearly distinct from read/list tools, but it does not explicitly name alternatives such as invite_users to rule them out.

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

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

The phrase 'to see the app as a user' implies the use case, but there is no explicit when-to-use guidance, no exclusions, and no comparison against sibling tools like invite_users or email_users. Usage is inferred rather than stated.

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

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

Annotations already declare destructiveHint=true and idempotentHint=false, so the safety profile is known. The description adds important operational context: passcodes are set via protect_url and never in chat, and member lists are managed through add_people. It does not explain the 'internal' mode, but overall adds value beyond structured fields.

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 dense sentence with nested parentheses and semicolons; it is front-loaded and contains no filler, but the structure is cramped and harder to parse than necessary.

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 a destructive mutation with annotations covering safety and an output schema, the description covers the main modes and security-sensitive passcode handling. However, the unexplained 'internal' mode and confirm_token leave the agent with gaps for a 5-parameter 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 60% and the description clarifies the mode choices (passcode vs members) and the meaning of path ('/' whole site or a part) and emails. It omits the 'internal' mode and the confirm_token parameter, leaving gaps that the schema also does not fully cover.

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

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

States a specific verb ('Protects') and resource ('site or one path'), and distinguishes the passcode and members modes with concrete constraints. It does not explicitly contrast with the sibling 'unprotect', but the purpose is clear.

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

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

Explains when to choose passcode (set via protect_url, never in chat) vs members (invite-only via add_people on '/', or emails on a path), and points to list_people for verification. Lacks explicit when-not guidance, but mode selection is well covered.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false, idempotentHint=false and openWorldHint=true, so the safety profile is covered. The description adds real value by disclosing the asynchronous owner-approval step and status token, but omits practical behavior such as what happens if approval is never granted or whether an approval expires.

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

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

One front-loaded sentence with the operation stated first and the workflow caveat second; no filler. It is dense but not padded, though 'in full or amount' reads slightly awkwardly and references approve_url, which is not a parameter.

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?

An output schema exists, so return values need not be explained, and the approval flow is surfaced. Still, for a destructive money-moving tool the description leaves the required identifiers and the approval lifecycle vague, which is the main remaining hole.

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 43%, and the description compensates for just two fields: amount (full vs. partial) and confirm_token (status lookup). The three required identifiers site, plugin_id and item_id are explained nowhere, which is a material gap for an agent constructing a call.

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

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

States a specific verb and resource ('Refunds an order') plus the scope nuance of full vs. partial amount. It does not distinguish itself from the closely related siblings fulfil_order and refuse_order, leaving the agent to infer the boundary.

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?

Gives a concrete precondition — the refund only resolves once the owner approves the money on approve_url — and explains what confirm_token is for. It says nothing about when to prefer this over refuse_order or fulfil_order, so no explicit alternative routing.

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 flag destructive=true, idempotent=false and openWorld=true; the description adds genuinely new behavioral context: the refund is full, it is gated on owner approval at approve_url, and status is later checked via confirm_token. It stops short of saying what happens if approval never arrives or whether the order becomes unrecoverable.

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

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

A single dense sentence that front-loads the action, then the approval gate, then the status check. No filler and nothing redundant.

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?

An output schema exists so return values need not be explained, and the approval flow is covered. Still, for a destructive multi-site mutation with three required but undocumented identifiers, the description leaves the agent guessing how to supply site/plugin_id/item_id and what state the order ends in.

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 33%, with message and restock self-documented, and the description clarifies the role of confirm_token (status check). But site, plugin_id and item_id are unexplained, and approve_url is referenced as if it were a parameter although it is absent from the schema, which can confuse the caller.

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

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

The description states a concrete verb and resource ('Refuses an order') and adds the refund consequence, so the effect is unambiguous. It does not explicitly contrast with the sibling refund_order or cancel_transfer, so differentiation is partial.

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 workflow is implied ('once the owner approves the money on approve_url'), which tells the agent this is a multi-step, non-immediate action. However, it never states when to pick this over refund_order or how to handle an unapproved order, leaving exclusions to inference.

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

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

Annotations already declare destructiveHint=true and idempotentHint=true, so the safety profile is covered. The description adds genuinely new behavioral context — that removal is immediate and that pending deliveries are discarded — which an agent cannot derive from annotations or schema.