Nunify

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

Annotations already declare destructiveHint=true and non-idempotent, so the bar is lower; the description still adds real value by disclosing that activation queues delivery to actual recipients and is irreversible. It stops short of noting permissions, whether the mailer can be deactivated afterward, or what a partially-queued state means.

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

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

Two short sentences, zero waste, with the core action first and the risk warning immediately after. Nothing is repeated or padded.

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 and annotations covering the safety profile, the description supplies the key missing piece: that this triggers real sending and is irreversible. The remaining gap is routing guidance relative to send_test_mailer/deactivate_mailer, which an agent would still have to infer.

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

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

Schema coverage is 100% and both required parameters (event_id, mailer_id) carry their own descriptions, so the schema does the heavy lifting. The description adds no extra meaning about parameter formats or constraints, making the baseline 3 appropriate.

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

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

States a specific verb+resource ("Activate a mailer") and the second sentence clarifies the effect (queues sending to real recipients). It implicitly distinguishes itself from send_test_mailer by emphasizing real recipients, but never names the sibling, so differentiation is only 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 description implies this is the final, production-sending step for reminder/promotion/certificate mailers, which is useful context. However, it gives no explicit guidance on when to use it versus send_test_mailer, deactivate_mailer, or publish-style siblings, and no preconditions (e.g., preview or test first) are 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 the mutation profile (readOnlyHint=false, destructiveHint=false, idempotentHint=false), so the description doesn't need to restate safety. It does add value with the "static groups" constraint and the "manageable" permission hint, but it never says what happens on duplicate membership or with an invalid group id — relevant given idempotentHint=false.

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

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

Two sentences, zero waste, with the purpose front-loaded and the id-sourcing guidance following. Nothing could be cut without losing 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?

An output schema exists so return values needn't be explained, and the description covers purpose, the static-group constraint, and where to source both ids. The remaining gap is duplicate/error behavior on the pair array, which matters for a non-idempotent 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?

Schema coverage is 50%: event_id is documented in the schema, but the nested user_id and group_id fields are bare. The description partially compensates by pointing to read_attendees and read_groups as the id sources, but nothing explains the pair-batch batching semantics or whether pairs must be homogeneous.

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 ("Add attendees to static groups"), and the word "static" usefully narrows the operation versus dynamic groups or the sibling remove_attendees_from_groups. It does not explicitly name the counterpart tool, so an agent must infer the add/remove pairing from the verb.

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 concrete prerequisite routing: use read_attendees for attendee ids and read_groups for manageable group ids. That is real when-to-use context, but there are no exclusions such as what to do if a group is dynamic or if an attendee is already in the group.

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=false and idempotentHint=false, so the agent knows this is a non-idempotent write. The description adds a discovery pointer but says nothing about preconditions (must page/section exist?), failure behavior, or what the returned block looks like; the 'appended by default' behavior is already covered by the position parameter's schema text.

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 stated first and the prerequisite second. Nothing could be removed without losing 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?

Output schema exists and annotations plus full schema coverage handle most of the burden, so a short description is defensible for a create operation. The remaining gap is the dangling reference to a schema tool whose name is inconsistent with the parameter description and absent from the sibling list, which is the one thing an agent could trip on.

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% across all six parameters, including the nested 'properties' object and the position default, so the schema carries the parameter burden. The description only reinforces block_type semantics by pointing at the schema tool; it adds no format, merge-order, or valid-value detail beyond structured data.

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: 'Add a new block to a registration site section,' which is unmistakably distinct from update_site_block, remove_site_block and reorder_site_blocks. It stops short of naming those siblings explicitly, so differentiation is inferred from the verb rather than stated.

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 one useful prerequisite: consult the block-schema tool before choosing block_type. However, it offers no guidance on when to use this versus update_site_block or reorder_site_blocks, and the referenced tool name ('get_site_block_schema') neither matches the schema's own reference ('get_block_schema') nor appears in the sibling list, leaving the agent unsure which call to make.

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, idempotentHint=false), so the description need not restate safety. However, it adds no context about the non-idempotent behavior (repeated calls create duplicate sections) or what happens if the preset is invalid, leaving gaps the annotations only imply.

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

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

Two short sentences with the action front-loaded and the dependency hint following; there is no filler and nothing is buried.

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 and full schema coverage, the description needs only purpose and routing, both of which it supplies. It is slightly thin on mutation prerequisites (page state, event/page relationship), but nothing essential to invoking the tool is missing.

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

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

Schema description coverage is 100%, so all four parameters are already documented, including the fact that position defaults to append and that preset_name comes from list_site_section_presets. The description largely repeats the schema's preset_name hint and says nothing extra about position semantics, so 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?

Names a specific verb (add) and resource (a preset section on a registration site page) and scopes it by preset name. It is clearly distinct from add_site_block and remove_site_section, though it never explicitly contrasts itself with add_site_block, which is the nearest sibling.

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

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

"Use list_site_section_presets to see available preset names" gives an explicit discovery workflow for the required preset_name argument. It does not state when to choose this over add_site_block or what preconditions (draft page, existing page) apply.

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, and readOnlyHint=false, so the safety profile is covered. The description does add a genuinely useful consequence: the flow leaves lists and in-progress runs end — though the garbled phrasing ('runs in progress end') blunts the disclosure.

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 is appropriately sized and the purpose is front-loaded. The second sentence is ungrammatical and ambiguous ('runs in progress end'), so brevity comes at the cost of clarity.

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, full annotations, and complete parameter documentation, the structured fields carry most of the burden. The description is minimally adequate but omits reversibility, permissions, and the archive-vs-unpublish distinction 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?

Schema coverage is 100% and both parameters are documented with their source tools (list_flows, search_events). The description adds nothing about flow_id or event_id, 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+resource ('Archive a Zuno flow') that is easy to separate from create_flow, update_flow, and delete_* siblings. It does not, however, distinguish archiving from unpublish_flow, which is the closest ambiguous neighbor.

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 guidance on when to archive instead of unpublish_flow or delete, and no prerequisites or reversibility notes. The agent must infer the choice entirely from the tool name.

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

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

Annotations already declare the safety profile (non-destructive, non-idempotent, closed-world). The description adds the side effect of unsubscribing from push channels, which is useful behavioral context. However, it does not mention permission requirements, reversibility, or rate limits.

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

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

The description is a single, front-loaded sentence with zero waste. It efficiently conveys the core action and key side effect.

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

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

Given that annotations cover safety and an output schema exists, the description is largely complete for an agent to invoke the tool. The addition of the unsubscription side effect is valuable. Minor gaps include not stating whether the ban is reversible or what happens if the attendee is already banned, but these are not critical for a simple mutation tool.

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

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

Schema coverage is 100%, so both parameters are fully documented in the schema with descriptions indicating UUIDs and that event_id comes from search_events. The description adds no additional parameter semantics beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description states a specific verb (ban) and resource (attendee), specifies the scope ('provided event'), and adds the secondary action of unsubscribing from push channels. It does not explicitly differentiate itself from siblings like unban_attendee or delete_attendee, but the action is clear enough to distinguish.

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

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

The description provides no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. It merely states what the tool does, leaving the agent to infer the appropriate context from the tool name and other information.

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, and readOnlyHint=false; the description earns credit by adding the actual behavioral consequence (answer submission is blocked) and by pointing at reopen_poll, which signals the change is reversible. It does not address what happens if the poll is already closed or whether an error/rate limit applies, which matters given idempotentHint=false.

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

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

Two tight sentences: the state-changing effect is front-loaded, and the recovery path follows immediately. Nothing is repeated from the schema or 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?

Return values are covered by the output schema and both required params are documented, so the definition is essentially callable as written. The only gap is behavior on an already-closed poll, which is relevant given idempotentHint=false.

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

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

Schema coverage is 100% and both parameters are described in the schema itself (poll_id as UUID of the published poll, event_id as an Event UUID from search_events). The description adds no additional parameter meaning beyond that, 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 ('Close a published poll') plus the concrete effect ('so no new answers can be submitted for the provided event'), which lets an agent distinguish it from delete_poll, publish_poll, and the survey equivalents 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?

Names the alternative and the condition that selects it ('Use reopen_poll to allow answers again'), giving clear when/when-not guidance. It does not discuss other plausible alternatives such as delete_poll or unpublishing, so it falls short of fully exhaustive routing guidance.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false, and idempotentHint=false. The description adds real value beyond them by stating the operational meaning (no new responses accepted) and pointing at the undo path, though it does not clarify whether existing responses are preserved or whether a second call errors despite idempotentHint=false.

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

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

Two sentences, zero filler, with the effect statement front-loaded ahead of the recovery pointer. Nothing could be removed without losing 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?

Output schema exists so return values need no explanation, and the two required params are fully covered by the schema. For a destructive state-change tool, the description could still say what state the survey lands in and whether existing responses survive, which keeps it from a 5.

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

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

Schema coverage is 100%, so both parameters are fully documented in the schema. The description only lightly adds meaning ('published survey' implies a state constraint on survey_id), which is enough for the baseline 3 but nothing more.

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+resource (close a published survey), scopes it to an event, and states the concrete effect: no new responses can be submitted. It also names the inverse sibling reopen_survey, distinguishing it from publish_survey/delete_survey in the sibling 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?

Explicitly routes the agent to reopen_survey for the reverse operation, which gives a clear when-to-use-this-instead signal. It lacks any precondition guidance (e.g. what happens if the survey is not published or already closed), so it falls short of a full 5.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, idempotentHint=false and openWorldHint=false, so the safety profile is covered structurally. The description adds a valuable prerequisite workflow (read metadata before creating) but says nothing about side effects on the live registration form, whether duplicate names are rejected, or whether the field goes live immediately. Useful addition, but not rich behavioral disclosure.

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

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

Three sentences, front-loaded with the action and followed by the prerequisite and the routing rule. The default-field enumeration is long but functional rather than filler; nothing is 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?

For an 11-parameter mutation with nested objects, the description covers purpose, precondition and correct alternative, and an output schema exists so return values need no explanation. What's missing is guidance on the complex optional parameters (config, dependency, options vs session_ids) that the schema only partially documents.

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 64% and 11 parameters exist, so several (config, position, dependency, ticket_type_ids) are undocumented in both schema and description. The description's main contribution is semantic: it defines which names are reserved default fields, which meaningfully constrains the required `name` parameter. That is real added value, but it does not compensate for the remaining 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?

States a specific verb (create), resource (additional user field) and scope (the provided event's default registration flow). It also names the sibling it must not be confused with (update_default_user_field) and enumerates the reserved default field names, so the agent can distinguish it from related tools 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?

Gives an explicit pre-flight step (check registration metadata default_fields and existing additional_fields) and a hard routing rule: if the requested name matches a default field, use update_default_user_field instead. This is exactly the when-to-use/when-not-to-use/alternative structure that scores top marks.

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 only declare readOnly=false, destructive=false, idempotent=false; the description adds the non-obvious trait that the tool is batch-limited to 10 items and must be called repeatedly for larger sets. That is genuine behavioral context beyond the structured fields. It stops short of covering partial-failure or duplicate-handling behavior, which matters for a non-idempotent write.

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

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

Two short sentences with zero filler, front-loading the core action and then the batching constraint an agent must respect. Nothing could be removed without losing 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?

An output schema exists so return values need no explanation, and the critical batching loop is documented. Remaining gaps are minor but real: the relationship between addons and ticket_type_ids, and what happens if a mid-batch call fails, are left to inference.

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

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

Schema coverage is 100% at the top level, so the schema carries the parameter documentation and baseline 3 applies. The description adds only the 10-item batching constraint (already mirrored in the addons schema description) and says nothing about nested fields such as amount, quantity, is_enabled, or ticket_type_ids.

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 ("Create ticket addons") plus scope ("in the provided event"), which is far more informative than the bare title. It distinguishes itself from update_addon/delete_addon by naming the create action, though it never explicitly contrasts with those siblings.

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

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

The description gives a procedure for the >10 case, which implies when and how to call repeatedly, but it never states prerequisites (event must exist, permissions) or when to prefer update_addon over re-creating. Usage is implied rather than spelled out.

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 the safety profile (not read-only, not destructive, not idempotent), so the bar is lower. The description adds genuinely operational context: the execution loop for >10 attendees, which the agent must implement itself. It doesn't warn that non-idempotent retries of a partially completed batch will duplicate attendees, nor what happens on per-attendee validation failure.

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

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

Three sentences, front-loaded with the action, then the batching procedure, then dependency routing. Slight redundancy: the >10 instruction appears here and again in the attendees parameter description, and the 'Provided event' phrasing adds nothing.

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 2 parameters, full schema coverage, and an output schema covering returns, the description is nearly sufficient. What's missing for a bulk mutation is failure semantics — partial success, duplicate detection, and whether the caller should stop the loop on error.

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

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

Schema coverage is 100%, so the baseline is 3. The description's 'batches of 10' restates the schema's maxItems constraint, and its id-lookup hints largely duplicate schema text ('Use read_interests action \'list\' to get valid ids'). It adds little semantic 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?

Opens with a specific verb+resource+scope: 'Create attendees in batches of 10 in the provided event.' The batching constraint and event scoping distinguish it immediately from update_attendee, delete_attendee, and add_attendees_to_groups.

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 concrete prerequisite routing — read_attendees for inspection, read_groups for group ids, read_interests/read_services action 'list' for valid ids — so an agent knows what to call first. It stops short of stating when not to use this tool (e.g., adding existing attendees to groups, or updating already-created attendees).

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 is a non-readonly, non-idempotent, non-destructive mutation, so the safety profile is covered. The description adds the important batch-of-10 constraint, but it is ambiguous about whether the tool loops internally or the caller must issue repeated calls — the schema implies the caller must, while the description reads as if the tool handles it. That ambiguity is exactly the kind of behavior an agent needs disambiguated for a repeat-invocation pattern.

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

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

Two sentences, front-loaded with the action and scope, then the batching rule. No filler, no repetition of 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?

An output schema exists, so return values need not be explained, and the mutation semantics are covered by annotations. What is missing is the one thing that actually determines correct invocation behavior: who performs the batching — the tool or the agent issuing successive calls — and what happens if a coupon code already exists.

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

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

Schema description coverage is 100%, so the schema already documents event_id, the coupon object fields, and the maxItems=10 cap. The description restates the 10-item batch limit but adds no meaning about the per-coupon fields (discount_type, quantity, ticket_type_ids) beyond the schema. Baseline 3 is appropriate.

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

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

States a specific verb and resource ('Create coupon codes') plus a scope ('in the provided event'), which cleanly separates it from update_coupon_code and delete_coupon_code. It does not explicitly name those siblings, so differentiation relies on the reader's inference.

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 batching rule ('create the first 10, then continue with the next 10') is genuine operational guidance for using the tool. However, there is no statement of when to choose this over update_coupon_code, no prerequisite that event_id comes from search_events (that lives only in the schema), and no guidance on duplicate codes or how to handle partial failure.

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 annotations (readOnlyHint=false, destructiveHint=false, non-idempotent), the description adds meaningful behavioral context: the event code is auto-generated from the name, default provisioning includes registration form, ticketing, and configs, and template content copying runs asynchronously after creation. These details help an agent understand side effects and timing, though it doesn't cover failure modes or permission requirements.

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

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

The description is front-loaded with the core action and efficiently packs key behavioral notes into four well-structured sentences. Every sentence contributes essential information without redundancy or fluff.

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

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

Given the tool's complexity (8 parameters) and the presence of an output schema, the description covers all essential aspects an agent needs to invoke it correctly: default provisioning, template copying behavior (including async), and team context. Nothing critical is missing.

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

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

With 100% schema description coverage, the baseline is 3. The description adds value by explaining the async nature of template content copying and clarifying the 'instead' semantics of template_id (replacing default provisioning). It also succinctly restates the team_id condition, though other parameters rely on the schema for details.

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

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

The description clearly states a specific verb ('Create') and resource ('event'), and specifies scope ('in one of your teams'). It distinguishes this tool from other create_* siblings by focusing on events and explains the unique auto-generation of event code, leaving no ambiguity about what the tool does.

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

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

The description provides clear context for when to pass template_id (to copy an existing event's layout and content instead) and when team_id is needed (only when belonging to multiple teams). It stops short of explicitly stating when not to use this tool or naming a direct alternative for event creation, which is reasonable given no sibling performs the same core action.

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 is a non-read-only, non-idempotent, non-destructive write, so the safety profile is covered. The description adds genuinely useful behavior about the 10-item batch limit and iterative continuation, but says nothing about duplicate handling, partial-failure behavior, or required permissions for a creation tool that is explicitly non-idempotent.

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

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

Two short sentences, front-loaded with the core action and the batch constraint. The second sentence partially restates what the schema's maxItems description already says, which is mild redundancy, but there is no wasted prose.

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 and 100% parameter documentation, the definition is callable as written. However, for a non-idempotent bulk-create tool it omits what an agent would want: duplicate-name behavior, what happens if a batch partially fails, and whether the caller must re-invoke with remaining batches after an error.

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

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

Schema coverage is 100%, and the schema itself already documents event_id lookup via search_events, the required name rule, UUID sources for interests/services, and the maxItems=10 continuation pattern. The description repeats the batching constraint but adds no format or validation detail beyond the schema, so 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?

The description states a specific verb and resource ('Create exhibitors') scoped to a provided event, which clearly separates it from create_exhibitor_category, create_sponsor, and update_exhibitor. It doesn't explicitly name those siblings, but the resource noun is unambiguous.

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

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

Usage is implied: add new exhibitors to an event. No guidance is given about when to use create_exhibitor versus update_exhibitor, how to check for existing exhibitors first, or what prerequisites (event must exist) are required. The batching instruction is a procedure, not a selection guideline.

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 is a non-read-only, non-destructive, non-idempotent mutation, so safety is covered. The description adds the batching protocol, which is genuine behavioral context, but it omits the important unknowns for a batched write: whether earlier batches persist if a later one fails, duplicate-title handling, and retry 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?

Two short sentences, front-loaded with the verb and the batching constraint. Slightly redundant in restating the 10-item loop twice, but no filler and nothing 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 and annotations exist, so return-shape and safety needn't be explained. However, for a batched create tool, the description should clarify partial-failure and duplicate behavior so an agent knows whether to retry; that gap leaves it only adequate.

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

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

Schema description coverage is 100%, so both parameters are already documented, including the maxItems:10 batching note. The description repeats that same batching semantics rather than adding new meaning beyond the schema; 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 ('Create') plus specific resource ('exhibitor categories') scoped to a provided event. The name overlaps with create_exhibitor, but the description's resource wording still disambiguates. It stops short of naming a sibling or exclusion 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?

It gives a usage protocol for >10 categories (create in batches of 10, iterating), which implies the call pattern. But there is no statement of prerequisites (e.g., needing a valid event_id from search_events), no when-not guidance, and no mention of update_exhibitor_category as the alternative for existing categories.

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 a non-destructive, non-idempotent write, and the description adds real value beyond them: the created object is a non-public draft, its visibility flips only at publish_flow, and the response carries validation output. It doesn't mention auth/permission requirements, but the draft-state semantics are exactly the kind of context annotations can't convey.

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 sentences, front-loaded with the action and the two input modes, then the lifecycle constraint, then the return signal. 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?

Given an output schema exists, the description needn't enumerate return fields, and it still flags the validation payload. For a 6-parameter create tool with full annotation and schema coverage, an agent has everything needed to call it correctly.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds the either/or semantics between template_key and spec that the schema only gestures at ('Either template_key or spec'), and the schema's spec description is unusually detailed. Marginal added value above the structured fields.

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 ('Create a draft Zuno flow') and names the two mutually exclusive creation modes (template_key vs spec). The mention of publish_flow and the validation in the response clearly separates it from sibling tools like update_flow, publish_flow, and validate_flow.

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 the lifecycle context — the draft is invisible to attendees until publish_flow — which tells an agent this is step one in a create/publish workflow, and the schema nudges toward validate_flow before submitting a spec. It stops short of explicitly contrasting with update_flow or stating prerequisites like event ownership.

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

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

Annotations declare readOnlyHint=false, destructiveHint=false and idempotentHint=false, so the write semantics are already structured. The description adds a genuinely new behavioral trait: dynamic membership is applied asynchronously ("users matching the rules are added in the background"). It does not cover permissions, whether duplicate group names are rejected, or what happens if the rules match nobody.

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

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

Three sentences, no padding, and the static-vs-dynamic decision is front-loaded before the prerequisite detail. Every sentence carries a distinct instruction.

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 described. For a 3-parameter create tool with annotations covering the safety profile and a fully documented schema, the description supplies the one missing piece an agent cannot get from structured fields: the conditional mode selection and the prerequisite field-lookup step.

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

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

Schema coverage is 100%, so the schema already documents name, event_id, rule_sets and the nested rule fields. The description's parameter guidance (omit rule_sets for static, only use field_name values from list_rule_fields) largely restates the schema's own field descriptions, adding only the background-matching behavior, 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 ("Create a static or dynamic group") and immediately distinguishes the two creation modes an agent must choose between. The read_groups reference signals how this tool relates to the group-management siblings (read_groups, delete_group, add_attendees_to_groups).

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 branch conditions: pass rule_sets for a dynamic group, omit it for a static one. It also names the required prerequisite step (read_groups with action 'list_rule_fields' first) and the constraint on the values it returns, leaving nothing 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 cover the safety profile (readOnly=false, destructive=false, idempotent=false, closed-world), yet the description still adds substantive behavior: each interest auto-creates a backing group and creation fails on an unrelated name collision. The collision-driven failure also explains why the tool is non-idempotent. It does not say what happens if a batch partially fails mid-run, keeping it below 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 front-loaded sentences with the core action first, then the batching loop, then the group side effect. Slight redundancy with the schema's maxItems/description of 'interests', which already explains the 10-item chunking.

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 covers the side effect, failure mode, and batching workflow an agent must handle. It omits permission/authorization requirements and any partial-failure semantics, which keeps it from a 5.

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

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

Schema description coverage is 100% and both parameters are documented in-schema (event_id from search_events, maxItems=10 on interests). The description's batching text largely restates the schema's own maxItems guidance, adding only marginal meaning, so the baseline of 3 applies.

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

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

States a specific verb ('Create') and resource ('interests') scoped to a single event, and the batching constraint makes it unmistakable against siblings like update_interest, delete_interest, and read_interests. An agent can tell what this does 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?

The description spells out the operational loop: create the first 10, then the next 10, until all are created, which is real procedural guidance. It stops short of naming alternatives or exclusions (e.g., when to use update_interest for existing interests, or create_group), so it does not reach a 5.

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

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

Annotations already declare readOnly=false, destructive=false, idempotent=false; the description contributes the batching constraint, which is a genuine behavioral trait beyond the annotations. It does not address what happens on duplicate room names, whether creation is atomic across the batch, or permission requirements — notable gaps given idempotentHint=false.

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

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

Purpose is front-loaded and the whole thing is four short sentences. The batching sentences repeat what the schema's maxItems and locations description already say, so there is some redundancy, but nothing is padded or vague.

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, full annotation coverage and 100% schema descriptions, the description only needs to convey purpose, batch mechanics and downstream consumers — all of which it does. Missing only edge-case behavior (duplicates, partial failure), which is a modest gap for a create tool.

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

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

Schema description coverage is 100%, so event_id, title, can_checkin, checkin_limit and checkin_message are already fully documented, including the strong "never invent titles" rule. The description adds no parameter-level meaning beyond what the schema states, 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 concrete verb and resource ("Create locations") scoped to "the provided event," and adds domain framing that locations feed sessions, exhibitors and check-ins. It is unambiguous against siblings like update_location or read_locations, 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?

Provides real procedural guidance for the >10 case (create in batches, continue in chunks of 10). But that is invocation mechanics rather than when-to-use/when-not guidance, and it gives no signal about using create vs update_location or how to handle already-existing locations.

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 non-read-only, non-destructive, non-idempotent, closed-world, and the description adds the crucial non-obvious state trait: the mailer is created inactive, so nothing sends until another call. It doesn't cover auth/permission needs or rate limits, so not 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 short sentences, front-loaded with the create action, then the inactive-state consequence, then the template-editing follow-up. No filler or restated parameter lists.

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

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

Output schema exists so return values needn't be explained, params are fully documented in schema, and the description supplies the lifecycle state (inactive) plus next-step tools an agent needs to complete a mailer workflow. Nothing essential is missing.

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

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

Schema description coverage is 100% and each of the 14 params is documented inline (kind immutability, event_id source, group_ids conditional on access_level, feature_selection_id constraints), so the schema does the heavy lifting. The description adds only the email_template_id editing pointer, which refers to a returned field rather than a create parameter, so 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+resource ('Create a new email mailer') with scope ('for the provided event'), and explicitly names the sibling tools this is not (activate_mailer, schedule_mailer, update_email_template). An agent can tell it apart from duplicate_mailer or update_mailer 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 states the when: create here, then use activate_mailer to start sending or schedule_mailer for later delivery, and update_email_template (with email_template_id) to change body/html. This is direct routing to the correct alternatives, not 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 write, destructive, and non-idempotent behavior. The description adds useful behavioral context beyond annotations: batching in groups of 10, default draft state, immediate vs scheduled publishing, and rejection of timezone-bearing datetimes. It still does not disclose permission requirements or email side effects, but those are secondary given the annotation coverage.

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

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

The description front-loads batch size and event scope, then covers defaults, publishing modes, conflict rules, and timezone handling in five tight sentences. There is no filler, and each sentence contributes to correct invocation.

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

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

Given the nested notifications array, 10-item limit, required fields, and existing output schema, the description covers the critical calling behavior: batching, default drafts, immediate vs scheduled publishing, the publish/scheduled_at conflict, and timezone rejection. Field-level warnings such as required text and access_level are handled by the schema, so the description is complete enough for correct use.

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

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

Schema description coverage is 100%, and the nested fields including publish, scheduled_at, access_level, and text are already well documented in the schema. The description reinforces the publish/scheduled_at conflict and timezone rule, but adds little syntax or semantics beyond what the schema already provides.

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

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

The description opens with a specific verb and resource ('Create notifications') and scope ('for the provided event'), and clarifies draft vs publish vs scheduled behavior. It does not explicitly distinguish itself from sibling tools such as publish_draft_notification, so it is clear but not fully differentiated.

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 clear operational guidance for the three modes: default draft, publish=true for immediate send, and scheduled_at for later delivery, plus the rule that publish and scheduled_at cannot be combined. It does not explicitly state when to prefer this tool over siblings like publish_draft_notification or update_notification_schedule, so sibling alternatives are absent.

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 destructiveHint=true, but the description adds the crucial context for why: publish=true makes the poll immediately visible to attendees, versus the safe default of drafts. That is real added value. It does not address the non-idempotent hint (retries after partial batch failure will duplicate polls), which is the main residual risk for a batch 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?

Four sentences, front-loaded with the batching rule and the draft default, then the destructive exception. The batch-of-10 instruction is restated in the schema, so there is minor redundancy, but nothing is padding.

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 nested item schema carries the per-poll field detail. The description covers the batch ceiling, the default state, and the destructive path. It could go further on failure/partial-success behavior for a non-idempotent batch write, which is the one gap an agent could trip on.

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

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

Schema description coverage is 100%, so the nested poll fields (publish, poll_options, is_word_cloud, colors, etc.) are already fully documented. The description's only addition is restating the publish=true consequence and the default-draft behavior, which the schema partially covers. Baseline 3 is appropriate.

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

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

States a specific verb and resource ('Create polls ... for the provided event') plus the supported poll types (multiple choice or word cloud), so the agent knows exactly what it produces. It does not explicitly distinguish itself from siblings like publish_poll or create_survey, so an agent must infer that this is the bulk-creation path.

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 operating guidance: batches of 10 with an explicit continue-with-the-next-10 loop, and a stated default of draft creation. What is missing is routing guidance against alternatives — nothing says when to use this versus publish_poll (which presumably publishes an existing draft) or when a poll should be a survey instead.

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 is a non-read-only, non-idempotent, non-destructive mutation, so the safety profile is covered. The description contributes the event-scoped, either-bank requirement but doesn't explain side effects, whether position defaults to the end, or what happens to ordering. Adequate, not rich.

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

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

Two sentences, zero filler, with the core action and the key identifier requirement front-loaded. Every sentence earns its place.

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

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

An output schema exists, so return values needn't be explained, and the schema documents the type-specific parameters. Still, for a 15-parameter tool where question_type silently determines which of options, rating_scale, slider_min/max, min/max_selections are required, the description gives no signposting to that coupling, leaving 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?

Schema coverage is 100%, so every parameter already has a description (including the survey_id/assessment_id either-or rule the description repeats). The description adds no extra meaning about type-dependent requirements, which is the main semantic burden for this tool. 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?

The description states a specific verb and resource ('Add a question to a survey or assessment') and scopes it to an event, which is clear enough for an agent to distinguish it from create_survey or update_question. It stops short of explicitly naming sibling alternatives, so it doesn't reach 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 gives a prerequisite-style cue ('Provide either a survey_id or assessment_id plus the question text and type') but says nothing about when to use this versus update_question, create_survey, or create_poll, and offers no exclusions. Usage is implied 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 readOnly=false, destructive=false, idempotent=false and openWorld=false, and the description's batching instruction is consistent with a non-destructive but non-idempotent write. It does not disclose what happens on partial failure mid-batch, whether retries duplicate records, or how duplicates are handled – meaningful gaps for a looped write operation.

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

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

Two short sentences, front-loaded with the core action and batching rule. The second sentence largely duplicates what the services schema property already says, which is minor waste but not harmful.

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. However, for a non-idempotent batched create the description omits failure/rollback semantics and whether all batches must be issued by the caller in sequence – an agent can be left uncertain how to recover from a mid-batch error.

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

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

Schema description coverage is 100% and both parameters are already documented in the schema, including the 10-item cap and how to continue past it. The description restates that same cap but adds no new meaning about event_id sourcing or service object shape, so 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 ('Create services') plus the scoping container ('in the provided event') and the batching constraint. An agent can identify the operation immediately, though it does not disambiguate from adjacent siblings like create_sessions or update_service.

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 procedural guidance on how to invoke it in chunks of 10 ('create the first 10, then continue with the next 10'), which is genuinely useful. It gives no guidance on when to prefer this over alternatives (read_services to check existing, update_service to modify) or what to do about name collisions.

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 is a non-read-only, non-destructive, non-idempotent write with no open-world access. The description adds the concrete batch ceiling of 10 per call, which is real behavioral context an agent needs. It omits what happens on partial failure, whether duplicate titles are rejected, and the fact that re-invocation (non-idempotent) can create duplicates.

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?

Front-loaded with the action and the batch rule immediately after, which is the right ordering. The batching instruction is stated twice in near-identical phrasing, and it also duplicates the categories parameter description in the schema, so there is some redundancy.

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

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

With a full output schema, 100% parameter coverage, and explicit annotations, the description only needs to carry the calling convention, which the batch rule does. Missing is any note on how categories relate to existing ones (duplicates, ordering) — minor given how much structured data 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?

Schema description coverage is 100%, so both event_id and the nested category fields are already fully documented, setting the baseline at 3. The description's only addition is the image URL line, which is slightly weaker than the schema ("for categories that need images" versus image_url being strictly required), so it adds no clarification 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 ("Create one or more session categories") scoped to a required event. It does not distinguish itself from nearby siblings such as create_sessions, update_session_category, or delete_session_category, so an agent must infer the boundary from the name 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 gives operational guidance about batching (10 at a time, continue with the next 10), which is genuinely useful for how to call it. It says nothing about when to choose this tool over update_session_category or delete_session_category, nor any prerequisites such as category uniqueness or event state.

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 is a non-readonly, non-destructive, non-idempotent write, so the safety profile is covered. The description adds real behavioral context the annotations cannot: the timezone-datetime contract and the forced 10-item batching loop. It stops short of saying what happens on partial failure mid-batch or whether retries duplicate sessions (relevant given idempotentHint=false).

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

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

Four sentences, zero filler, with purpose and the timezone constraint front-loaded before the batching mechanics. The batching instruction is slightly redundant with the schema's maxItems=10 and its own nested description, but the 'continue with the next 10' loop adds something the schema cannot express.

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 schema documents every nested session field. The description covers the two things structure cannot: timezone formatting and paginated batching. The remaining gap is failure/retry behavior for a non-idempotent batch create, which a calling agent would want to know.

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

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

Schema coverage is 100% and the properties are documented in detail, including required-field and never-invent guidance for title/start_time/end_time. The description restates the timezone rule for start_time/end_time that the schema already states, and adds only the get_agenda_metadata sourcing hint for track/category/location ids. Baseline 3 is appropriate.

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

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

States a specific verb and resource up front: 'Create agenda sessions in the provided event.' Combined with the id-sourcing hint (get_agenda_metadata) and the batching rule, it separates this tool from create_session_categories, create_speakers, and create_tracks without the agent needing to inspect sibling schemas.

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 concrete operating conditions: naked local datetimes in the event timezone, batches of exactly 10, and ids pulled from get_agenda_metadata. It does not state when to use update_session instead of create_sessions, or what to do if a session already exists, so the alternative-routing is only implied by the verb.

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 is a non-read-only, non-destructive, non-idempotent, closed-world write, so the safety profile is covered. The description adds one genuine behavioral constraint (slug '/' ownership), but does not say what happens on duplicate slug, whether the page starts as a draft, or whether it is immediately live—significant gaps for a creation 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?

Two short sentences, front-loaded with the action and resource, with the constraint second. No filler, though the second sentence could be folded in without loss.

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

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

Output schema exists, so return values need not be explained, and the schema is rich on parameters. But for a write tool creating a site page, the description omits publication state (draft vs live), duplicate-slug behavior, and permission requirements—material gaps an agent would want before invoking.

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

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

Schema description coverage is 100% and the config object enumerates supported keys extensively, so the schema carries the parameter burden. The description adds nothing about slug format, title requirements, or event_id that the schema does not already state better.

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 ('Create a new page on the registration site') plus the two identifying fields. It is clearly distinguishable from update_site_page and duplicate_site_page, 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 reserved '/' rule is an implicit routing hint toward update_site_page for the home page, and the create-vs-update distinction is obvious from the name. But there is no explicit statement of when to use this versus duplicate_site_page or update_site_page, and no prerequisites are given.

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

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

Annotations already cover the safety profile (readOnly=false, destructive=false, not idempotent, closed-world), so the description's added value is the upsert-by-email behavior: existing users are reused rather than duplicated. That is meaningful behavioral context an agent cannot infer from annotations or schema. It still omits bulk failure semantics (partial success, what happens if one speaker is invalid).

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 sentences, front-loaded with the action and scope, followed by the definition and the reuse rule. No redundancy or filler.

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

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

With a full schema, an output schema, and annotations present, the description covers the key ambiguity (dedupe by email) and the batching cap. It is essentially complete for calling the tool; only error/partial-failure behavior in bulk is 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 coverage is 100% and the schema already states the 10-item cap, required fields, and the no-inventing-emails rule. The description restates 'in bulk' and the email-matching semantics but adds no format or syntax detail beyond the schema, 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?

The description gives a specific verb and resource (create speakers), names the scope (bulk, for one event), and even defines what a speaker is ('event users assigned to the speakers group'), which is genuinely clarifying. It does not explicitly differentiate itself from near-neighbors like create_attendee or read_speakers, 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?

Usage context is implied: this is the tool for adding multiple speakers tied to an event, and matching by email reuses existing users. But there is no explicit 'when to use this vs. create_attendee' or 'check read_speakers first' guidance, and no stated prerequisites 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 write, non-idempotent, closed-world, non-destructive, so safety is covered. The description adds genuinely useful behavior beyond that: a hard 10-item batching limit per call and the iterate-until-complete pattern, which an agent must know to avoid truncating a large sponsor list. It omits partial-failure/duplicate handling, so not 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 sentences, front-loaded with the core action, then the batching rule, then the ID-resolution hints. The batching sentence is somewhat repetitive ("create the first 10, then continue with the next 10 until all are created"), but that redundancy clarifies loop behavior rather than padding.

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 described, and the 10-per-call constraint is well communicated. However, it never explains how to obtain a valid sponsor_category_id (presumably create_sponsor_category or a list read), which is a required field on every sponsor object.

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%, including the maxItems=10 note and the read_interests/read_services pointers, so the description largely restates structured data. Baseline 3 is appropriate; the only added value is reinforcing the loop semantics for the sponsors array.

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 ("Create sponsors") scoped to "the provided event," which is enough to tell it apart from create_sponsor_category, update_sponsor, and read_sponsors. It doesn't explicitly name those siblings, but the create-vs-read/update distinction is unambiguous from the name plus verb.

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 concrete invocation guidance: batch in groups of 10, loop until all sponsors are created, and resolve interest_ids via read_interests action 'list' and service IDs via read_services action 'list'. No explicit when-not-to-use or pointer to update_sponsor for existing records, so it falls short of a 5.

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

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

The annotations already establish that this is a non-read-only, non-destructive, non-idempotent mutation, so the safety profile is clear. The description adds meaningful behavioral detail beyond annotations by specifying the 10-item batching rule and iterative continuation for larger sets.

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

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

The description is two tightly focused sentences, front-loaded with the action and the key batching constraint. There is no filler or redundant explanation.

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 create tool with rich schema coverage, clear annotations, and an output schema, the description covers the essential event scope and batching behavior. It does not discuss partial-batch failures or permission requirements, but return values are handled by the output 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 description coverage is 100%, and both event_id and categories are documented, including the maxItems constraint and batching language. The description mostly repeats the schema's batching note rather than adding new parameter semantics, so the baseline 3 is appropriate.

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

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

The description states a specific verb and resource ('Create sponsor categories') with clear event scope, and the resource name distinguishes it from sibling tools like create_sponsor and create_exhibitor_category. The batching qualifier adds further specificity about how the creation works.

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 clear operating context by explaining the 10-category batch procedure and what to do when more than 10 categories exist. It does not explicitly mention alternatives such as update_sponsor_category or when not to use this tool, so it falls just short of full 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 declare destructiveHint=true, and the description earns that by explaining exactly which argument triggers destructiveness and why (immediate attendee visibility) – a real addition beyond the flag. It stops short of noting that drafts are reversible or how authorization/moderators are affected.

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 sentences, zero filler, with the default behavior and the destructive caveat front-loaded before any elaboration. Every sentence carries distinct decision-relevant 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?

With an output schema present and full schema descriptions, the description needs only cover defaults and risk, which it does. It could mention that an empty survey has no questions until template_id or create_question is used, but the schema already handles that.

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

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

Schema coverage is 100%, so baseline is 3; the description still adds semantic weight by tying publish=true to an irreversible, attendee-visible outcome rather than merely 'publish immediately'. Remaining parameters are left entirely to the (already thorough) 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 ('Create') and resource ('survey') scoped to an event, and immediately clarifies the default draft outcome. An agent can distinguish this from publish_survey, close_survey, and create_question 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?

Gives clear conditional guidance: default is draft, pass publish=true for immediate publication. It does not, however, route the agent to the publish_survey sibling for surveys that already exist, so the alternative-selection story is incomplete.

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

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

Annotations already mark this as a non-read-only, non-destructive, non-idempotent, closed-world mutation. Beyond that, the description discloses the single most important behavioral trait: the API only accepts 10 records per call and the agent must issue repeated calls to finish a larger set. It does not say what happens on partial failure or whether already-created batches persist, 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?

Two short sentences, front-loaded with the operation and scope. The second sentence largely re-states the batching rule already encoded in maxItems, so there is minor redundancy, but nothing is wasted or buried.

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 only 2 required parameters, an output schema, and full annotation coverage, the description supplies the one thing structured fields don't fully convey as workflow guidance: how to loop over more than 10 ticket types. An agent can call this correctly after reading it.

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

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

Schema description coverage is 100%, so both event_id and the ticket_types item fields are already documented in the schema, including maxItems=10 and the continuation instruction. The description's batch explanation restates what the ticket_types property description already says and adds no field-level meaning beyond it; the 3 baseline applies.

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

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

The description states a specific verb and resource ('Create ticket types') plus the scope ('in the provided event') and the batching constraint. It is clearly distinguishable in practice from delete_ticket_type and update_ticket_type, though it never explicitly names or contrasts those siblings.

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

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

It gives concrete usage context: when the payload exceeds 10 items, split the work into successive calls of 10 until everything is created. There are no explicit exclusions or prerequisites (e.g. that event_id must come from search_events), so it stops short of full when/when-not guidance.

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

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

Annotations declare the write profile (readOnly=false, destructive=false, idempotent=false), and the description adds genuinely new behavior: the 10-item batch limit and the requirement to loop across multiple calls, which an agent could otherwise miss. It does not address duplicate handling or whether partial failures roll back.

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 sentences with the purpose front-loaded. The third sentence is somewhat redundant with the second, repeating the batch-of-10 progression, but it reinforces the loop behavior rather than adding noise.

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 full schema coverage, an output schema, and annotations, the definition covers what an agent needs to invoke it correctly, including the multi-call batching pattern. Missing only edge-case behavior such as duplicate titles or partial-failure handling.

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

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

Schema coverage is 100%, and the schema itself already enforces maxItems of 10 and documents that title/color are required and must not be invented. The description's batching statement largely restates the schema constraint, adding no new parameter-level meaning.

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 ('Create agenda tracks') and ties it to an event, so it is distinguishable from update_track and delete_track by name and verb. It does not explicitly contrast with create_sessions or create_session_categories, which are adjacent siblings an agent might confuse it with.

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

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

Provides clear procedural guidance: create in batches of 10, and continue iteratively until all tracks are created. It stops short of saying when to prefer this over update_track (e.g., for existing tracks) or what to do when a track already exists.

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=false, destructiveHint=false and idempotentHint=false, so the safety profile is covered structurally. The description adds the useful precondition that the mailer must be active, but says nothing about consequences (does it stop queued sends?), reversibility (can it be reactivated via activate_mailer?), or the failure mode when the mailer is already inactive.

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

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

Two short sentences, front-loaded, with the constraint immediately after the action statement. The first sentence is essentially a restatement of the tool name/title, so a small amount of the text is redundant rather than earning its place.

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

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

The tool has only two fully documented required parameters, an output schema, and annotations covering safety, so the description does not need to explain returns or parameters. The remaining gap is behavioral: it does not say what deactivation does to the mailer's scheduled sends or how to undo it.

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

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

Schema description coverage is 100%: event_id is documented as coming from search_events and mailer_id as the mailer UUID, so the schema carries the parameter burden. The description adds no syntax, format, or scoping detail beyond that, making the baseline 3 correct.

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 ('Deactivate a mailer') that clearly pairs against the sibling activate_mailer and is distinct from delete_mailer. It stops short of naming those siblings explicitly, so the differentiation is inferred from the verb rather than spelled 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 precondition 'Only allowed when the mailer is currently active' is a real usage constraint, but it is a state gate rather than guidance on when to choose this over alternatives such as delete_mailer or update_mailer. No exclusions or alternative-selection advice is offered.

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 and readOnlyHint=false, so the safety profile is covered. The description adds only the scope detail that the field is removed from the default registration flow; it says nothing about whether collected attendee answers for that field are destroyed, whether the deletion is reversible, or whether the flow must be unpublished first.

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 zero filler; the scope constraint ('default registration flow') is included early. It is efficient, though its brevity leaves the gaps noted in the other dimensions.

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 mutation on a live registration flow, the definition omits how to discover field_id, what happens to existing attendee data in that field, and any preconditions. The output schema covers the return value, but the call-time and consequence information an agent needs is missing.

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

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

Schema coverage is 50%: event_id is documented ('Event UUID returned by search_events') but field_id has no description at all, and the description does not compensate by explaining how to obtain a field_id or what it identifies. With half the parameters undocumented, the description adds essentially nothing to 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 (delete) plus resource (additional user field) and scopes it to 'the provided event's default registration flow', which is more than the name alone conveys. It doesn't explicitly name update_additional_user_field or create_additional_user_field as the non-destructive alternatives, but the operation is unambiguous.

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

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

There is no guidance on when to delete versus update (e.g., deactivate vs remove) an additional user field, no prerequisites such as required permissions or event state, and no warning that this affects the registration flow. The word 'one' only hints that deletion is single-record.

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, and readOnlyHint=false, so the safety profile is fully covered structurally. The description adds nothing beyond the annotations: it does not say whether deletion is permanent, what happens to attendees or orders referencing the addon, or whether the event must be in a particular state.

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

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

A single front-loaded sentence with no filler or redundancy. It is efficient, though its brevity reflects under-specification rather than disciplined economy.

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 mutation tool this is thin: no cascade/irreversibility notes, no auth or event-state prerequisites, and one of two parameters is undocumented. The presence of an output schema excuses it from describing return values, but the rest of the burden is unmet.

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% — event_id is documented ("Event UUID returned by search_events") but addon_id has no description anywhere. The description does not compensate by explaining what an addon_id is or where to obtain it (e.g., from create_addon or read_event_content).

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

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

The description uses a specific verb and resource ("Delete one ticket addon") and scopes it to a single addon within an event, which is clear. It doesn't explicitly distinguish itself from update_addon or delete_ticket_type, but the verb+resource combination makes its domain unambiguous.

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

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

There is no guidance on when to use this versus update_addon (to clear fields) or delete_ticket_type, and no prerequisites stated. An agent must infer entirely from the name that this is the removal path for an addon.

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, readOnly=false and non-idempotent, but the description adds genuinely new behavioral detail: this is a soft delete via a status flag plus an enqueued cleanup job, which tells the agent the effect is asynchronous. It stops short of stating reversibility or what the cleanup job actually purges.

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

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

A single sentence that front-loads the action and scope, then the mechanism. No filler and no repetition of the title or schema.

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

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

Annotations cover the safety profile and an output schema covers returns, so the description only needs to carry the operational nuance it already does. However, for a destructive mutation on an attendee it omits downstream consequences (tickets, orders, group memberships) and how this differs from ban_attendee, leaving a real gap for correct tool selection.

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

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

Schema coverage is 100% with both parameters explicitly documented (user_id, event_id), so the schema carries the semantics. The description only restates that the event scopes the operation; it adds nothing about format or validation beyond the schema. 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 (delete) and resource (one attendee) scoped to a provided event, and even discloses the mechanism (mark deleted + enqueue cleanup). It does not distinguish itself from sibling operations like ban_attendee or remove_attendees_from_groups, which share the 'make this attendee go away' surface.

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 when-to-use or when-not-to-use guidance is given. With siblings such as ban_attendee, remove_attendees_from_groups, and update_attendee, an agent must guess whether deletion, banning, or group removal is the intended operation; the description offers no routing criteria or prerequisites (e.g., pending orders, ticket refunds).

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. The description adds almost nothing beyond that—it does not say whether deletion is permanent, how it affects existing orders using the code, or what permissions are required. The only added nuance is that it deletes exactly one code from a given event.

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 is appropriately concise, though it borders on being too terse for a destructive operation.

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 handles return values and annotations cover the safety profile, so the description needn't explain those. However, for a destructive delete tool it leaves coupon_code_id undocumented and provides no usage guidance, which are clear gaps.

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

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

Schema coverage is 50%: event_id is documented as an Event UUID from search_events, but coupon_code_id has no description in the schema or the tool description. The description adds no meaning about either parameter and does not compensate for the undocumented field.

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 (delete), resource (coupon code), and scope (one, from the provided event). It is clearly distinguishable from create_coupon_code and update_coupon_code by the verb, 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?

There is no guidance on when to use this tool versus update_coupon_code or when deletion is appropriate. No prerequisites or conditions are mentioned beyond what the schema implies.

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, and openWorldHint=false, so safety is mostly carried by structured fields. The description adds only the 'one exhibitor' singularity and event scoping; it says nothing about irreversibility, whether associated data is also removed, or what the response contains, which is below what a destructive operation ideally warrants.

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 short, front-loaded sentence with no filler. It is efficient, though its brevity borders on under-specification rather than disciplined conciseness.

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

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

An output schema exists so return values need not be explained, but for a destructive mutation the description omits cascading effects, permission requirements, and confirmation semantics. With a partially documented schema and no annotations beyond the safety hints, the definition is too thin for an agent to invoke confidently.

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%: event_id has a description pointing at search_events, but exhibitor_id is a bare string. The description does not compensate by explaining where exhibitor_id comes from (e.g., read_exhibitors) or its format, leaving the undocumented half of the parameters unexplained 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 states a specific verb and resource ('Delete one exhibitor') and scopes it to an event, which distinguishes it from siblings like delete_exhibitor_category, update_exhibitor, and read_exhibitors. It doesn't explicitly name those siblings, but the resource noun is precise enough for an agent to differentiate.

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 guidance on when to use this versus update_exhibitor or delete_exhibitor_category, no prerequisites (e.g., retrieving IDs first via read_exhibitors), and no stated conditions or exclusions. The agent is left to infer all of the routing logic.

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 bar is lower, but the description adds nothing beyond restating the delete: it does not say whether deletion is permanent, what happens to exhibitors assigned to that category, or whether related records are orphaned. For an irreversible mutation this is a meaningful 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?

A single efficient sentence with no filler, but its brevity comes at the cost of under-specification rather than tight information design—there is nothing front-loaded beyond the purpose.

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

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

An output schema exists so return values need not be explained, and the annotations carry the safety/destructiveness profile. What is missing—cascade behavior and how to source category_id—keeps it short of fully complete, but the structured fields cover much of the burden.

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%: event_id is documented as an Event UUID from search_events, but category_id has no schema description and the description does not compensate—it never explains how to obtain a valid category_id (e.g., from read_exhibitors or a create/update 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 (delete) and resource (exhibitor category) with the scope constraint 'from the provided event'. It is distinguishable from delete_exhibitor or delete_sponsor_category by the resource noun, though the description never explicitly contrasts with those siblings.

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

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

No guidance on when to use this versus update_exhibitor_category or delete_exhibitor, no prerequisites (e.g., category must be empty), and no note about confirming the intended category before invoking. The only implied usage is the tool name itself.

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

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

Annotations already declare destructiveHint=true, idempotentHint=true, and readOnlyHint=false, so the safety profile is covered. The description adds real value beyond that by enumerating the group categories that will cause the call to be rejected, which the annotations cannot express. It does not say what happens to attendees assigned to the deleted group or what the failure mode looks like.

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: the action is front-loaded and the blocking constraints follow immediately. Every clause earns its place.

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

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

An output schema exists, so return values needn't be described, and annotations cover safety semantics. The remaining gap is what happens to dependent data (attendee membership) on deletion, which matters for a destructive group operation.

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

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

Schema description coverage is 100% and only two parameters exist, both required and documented (event_id with provenance from search_events, group_id as the group UUID). The description adds no format or sourcing detail beyond the schema, so a 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?

The description states a specific verb and resource ('Delete a group') and scopes it to a single event, which separates it from the many other delete_* siblings by resource. It doesn't explicitly distinguish itself from create_group or read_groups, but the destructive action is unambiguous.

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

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

The second sentence gives concrete when-not conditions: system groups and groups linked to ticket types, interests, addons, or services cannot be deleted. It stops short of naming an alternative path (e.g., read_groups to verify deletability, or remove_attendees_from_groups for membership cleanup), so the agent must infer next steps.

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 covered. The description adds only that the deletion is single-item and event-scoped; it says nothing about irreversibility, what happens if the interest does not exist, or whether related data is affected.

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 short sentence with no filler and the key constraint (one interest, scoped to an event) front-loaded. It is efficient but so thin that brevity shades into under-specification.

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 described, but for a destructive, non-idempotent mutation the description should cover permanence and the undocumented interest_id. Neither is addressed, leaving an agent without enough to call it confidently.

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% and interest_id has no schema description at all. The description hints that the ID identifies a single interest within the given event, but never says where to obtain that ID (presumably read_interests), so it 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?

The description uses a specific verb (Delete) and resource (one interest) scoped to an event, which is unambiguous. It does not name a sibling, but the create/update/read_interest family is distinguishable from the name 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?

There is no guidance on when to use this versus update_interest or read_interests, and no stated prerequisites such as resolving the interest_id first. The only implied usage is that a deletion always needs confirmation, which is never spelled out.

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=false, so the safety profile is covered. The description adds a genuinely non-obvious behavioral constraint — the meeting-room assignment blocks deletion — which is the key thing an agent needs beyond the structured data. Error/response behavior is left to 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?

Two sentences, zero waste. The action and scope come first, then the blocking constraint, which is the right front-loading for a destructive tool.

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

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

With a full schema, annotations and an output schema, the description only needs to carry the non-obvious constraint, which it does. Minor gap: it doesn't state the consequence (error vs. silent no-op) when the location is assigned to a meeting room, though that may be in the output 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 100%, and both event_id and location_id are already documented (including the hint that event_id comes from search_events). The description adds no interpretation of the parameters beyond what the schema states, so 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?

The description states a specific verb and resource ('Delete a location') and scopes it to 'the provided event', which is enough to distinguish it from read_locations or update_location. It does not explicitly name a sibling alternative, 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 gives a clear precondition ('can only be deleted if it is not assigned to a meeting room'), which is useful usage guidance. But it never says when to use this versus update_location (e.g., to detach or repurpose a location) or what to do when the constraint blocks deletion.

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 the valuable non-obvious constraint that deletion is conditionally blocked. It does not state whether the deletion is permanent or whether related mailer_logs are affected, which is the remaining behavioral gap for a destructive 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?

Three short sentences with the core action first and the preconditions immediately after; no filler or repetition of 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?

An output schema exists, so return values need not be explained, and the preconditions cover the main failure modes. What is missing is the fallback path for the blocked cases and any note on permanence, which matters for a destructive operation.

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

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

Schema description coverage is 100% and both parameters are documented in-schema, including that event_id comes from search_events. The description adds no meaning beyond the schema, 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 ('Delete a mailer') that clearly separates it from create_mailer, update_mailer and read_mailers. It does not explicitly distinguish itself from the sibling deactivate_mailer, which is the nearest ambiguous alternative for an agent holding an active mailer.

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 concrete blocking conditions — active mailers cannot be deleted, and some waitlist/registration kinds cannot be deleted once mailer_logs exist — which tells the agent when the call will fail. It stops short of naming the alternative action (deactivate_mailer) for the active-mailer case, so the agent must infer the fallback.

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

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

Adds real behavioral value beyond the annotations: the delete is soft (data retained rather than purged) and cancelling a scheduled notification's pending delivery is a disclosed side effect not visible in the schema. The annotations already carry destructive/idempotent hints, so this extra context is a genuine supplement rather than a repeat.

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, and the operation type and its side effect are front-loaded in that order.

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, full annotation coverage, and a 100%-documented input schema, the description only needs to supply the semantics that structure can't: soft-delete and schedule cancellation. It covers those but says nothing about recoverability or whether draft vs published notifications behave differently.

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

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

Schema coverage is 100% and both parameters are documented there, so the description only needs to add scope meaning. 'in the provided event' does confirm the notification is nested under event_id, but that is a marginal addition; 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 ('Soft-delete a notification') with a meaningful qualifier ('soft') that distinguishes it from a hard delete. It doesn't reference any sibling (e.g. read_notifications, update_notification_schedule, publish_draft_notification), which keeps it 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?

No statement of when to use this versus alternatives such as update_notification_schedule (to reschedule rather than cancel) or read_notifications (to locate the ID). Usage is only implied by the phrase 'in the provided event'.

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 structurally. The word 'soft-delete' is the one piece of added value — it tells the agent data is retained rather than purged — but the description never says whether the poll can be restored, whether it disappears from read_polls, or what happens to attached questions/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?

One short sentence, front-loaded with the operation and its key modifier. Nothing is wasted and nothing is buried.

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 and annotations cover safety and idempotency, so much of the burden is off the description. Still, for a destructive mutation the description omits recovery semantics and post-delete visibility, which are the questions an agent actually needs answered before calling it.

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

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

Schema description coverage is 100%, so poll_id and event_id are fully documented in the schema itself. The phrase 'for the provided event' reinforces event scoping but adds no format, constraint, or lookup guidance beyond what the schema already supplies; 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+resource ('Soft-delete a poll') and adds a qualifier ('soft') that materially shapes what the operation is. It does not explicitly distinguish itself from close_poll, reopen_poll, or publish_poll in the sibling set, 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?

There is no statement of when to delete versus when to close_poll or reopen_poll, both of which appear in the sibling list and represent plausible alternative intents. The agent is left to infer that 'delete' means permanent removal from active use rather than a state change.

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 readOnlyHint=false, so the danger profile is carried structurally. The description adds the useful context that the question must live in a specific question bank identified by either a survey or assessment ID. It does not say whether the removal is permanent, how in-flight responses referencing the question are handled, or what the response contains - meaningful gaps for a destructive operation.

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

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

Two short sentences with zero filler, and the action plus its scoping constraint are front-loaded before the parameter note. Nothing is repeated or padded.

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 all four parameters plus the required set are covered. The remaining gap is behavioral: nothing about irreversibility or side effects on collected responses, which matters even with destructiveHint=true carrying part of that load.

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

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

Schema description coverage is 100%, so the schema already explains event_id, survey_id, question_id and assessment_id. The description only restates the either/or relationship between survey_id and assessment_id, which the schema descriptions also state; it adds no syntax, format, or lookup-path detail beyond that.

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