agendaforge

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

Annotations only indicate readOnlyHint=false and destructiveHint=false, so the description carries the behavioral disclosure burden. It meaningfully reveals that the contact never sees the note, that execution may be immediate or routed to an approval proposal depending on organization settings, and that the response status field indicates which path occurred.

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

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

The description is three focused sentences: purpose and privacy, when to use versus an alternative, and behavioral expectations. It is front-loaded with the core purpose and contains no filler or redundant restatement of the tool name.

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 fully documented schema and the absence of an output schema, the description provides the necessary context an agent needs: privacy semantics, usage boundaries, approval workflow ambiguity, and a pointer to the response status field. Nothing essential for correct invocation is missing.

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

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

The input schema already provides 100% parameter descriptions, so the baseline is 3. The description adds high-level context about privacy and approval but does not add significant per-parameter meaning beyond what the schema already offers.

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

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

The description states a specific verb and resource: 'Record a PRIVATE internal CRM note about a contact.' It clearly distinguishes this tool from send_speaker_message by explaining the note is for internal organizer context, not for communicating with the contact.

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

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

It explicitly states when to use the tool ('only for internal context the organizer wants remembered') and names the alternative for a different need ('to ask a speaker to do something, use send_speaker_message instead'). This gives an agent clear decision criteria.

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

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

Beyond the annotations, the description reveals a key behavioral nuance: the operation may either execute immediately or file a proposal for approval, and the response status field indicates which occurred. This is useful conditional behavior that annotations do not convey, though it does not discuss permissions or side effects beyond the assignment itself.

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

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

The description is two sentences long, front-loads the core action, and then adds the essential conditional behavior. Every sentence earns its place with no filler or redundancy.

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

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

The description, combined with the fully covered schema and annotations, gives an agent enough to call the tool correctly. It explains the one conditional outcome that matters and points to the response status field, though it does not fully describe the response shape since no output schema is available.

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 parameters are fully documented in the schema. The description adds no extra parameter-level meaning beyond what the schema already provides, so the baseline score of 3 is appropriate.

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

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

The description states a specific verb and resource: assign a contact as a speaker on a session. This precisely distinguishes it from siblings like remove_session_speaker, schedule_session, and create_speaker_task, so an agent can tell what this tool 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 intended context is clear: use this when assigning a contact to speak on a session. It also explains the important contextual behavior that the action may execute immediately or become a proposal depending on org settings, though it does not name any alternative tool or explicitly state when not to use it.

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

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

Beyond the annotations, the description reveals critical behavioral details: the operation is idempotent, it may either execute immediately or file a proposal for approval depending on organization settings, and the response status field indicates which path occurred. This materially helps an agent interpret outcomes.

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

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

Three sentences with no filler. The core action is front-loaded, and each subsequent sentence delivers non-obvious information about idempotency and approval behavior.

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 write operation with no output schema, the description covers the essential ambiguities: the possible execution paths and how to detect which occurred. Combined with the fully documented input schema, an agent has enough information to invoke the tool correctly.

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

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

The schema already covers all parameter descriptions, so the baseline is 3. The description adds value by clarifying that ticketCode and ticketId are alternative ways to identify the attendee, which is not explicitly encoded in the schema's individual field descriptions.

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

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

The description states a specific operation: checking an attendee in, and identifies the accepted identifiers (ticket code or ticket id). This clearly separates it from sibling tools like list_attendees or get_contact.

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 first sentence explicitly establishes the tool's use case: checking in an attendee. It does not enumerate alternatives or exclusions, but the purpose is clear enough that an agent would know when to select it relative to the given siblings.

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

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

The readOnlyHint and destructiveHint annotations already communicate the non-destructive nature; the description reinforces this with 'without changing the schedule.' It could add more behavioral detail about what happens when conflicts are found or how conflicts are reported.

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

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

The description is a single, front-loaded sentence with no filler. It packs the core action, scope, and safety qualifier efficiently.

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

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

For a read-only conflict-checking tool with a complete input schema and safe annotations, the description is largely sufficient for correct invocation. A small gap is that it does not describe what the result looks like, and the schema does not explicitly state that at least one of placement/placements must be provided.

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 parameters are already well documented. The description's 'one or up to 20' adds modest clarity around the placement vs placements parameters but does not go beyond what the schema already states.

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 ('check'), a clear resource ('proposed session placements'), and an explicit scope ('one or up to 20') while also noting it does not modify the schedule. This clearly distinguishes it from scheduling tools like schedule_session.

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

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

The phrase 'without changing the schedule' establishes clear context for using this tool as a validation/simulation step before committing changes. However, it does not explicitly name an alternative tool like schedule_session or state when not to use this tool.

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

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

Annotations already indicate this is a write operation (readOnlyHint=false), and the description adds valuable behavioral context: the action may execute immediately or be filed for approval, and the response status field indicates which occurred. This goes meaningfully beyond the annotation and 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?

The description is two sentences with no filler. The key clarification ('creating is not sending') is front-loaded, and the second sentence efficiently conveys the approval behavior without over-explaining.

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?

There is no output schema, so the description appropriately tells the agent that the response status field reveals whether the action executed immediately or was proposed. It also covers the main ambiguity around sending versus creating. It could mention idempotency behavior, but the schema's request_id description already covers 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 description coverage is 100%, so the parameters are already well documented. The description does not add additional parameter-level meaning, but it also does not need to because the schema carries the full burden. 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 action ('Draft an event email template') with a clear resource, and explicitly distinguishes it from sending ('creating is not sending'). This makes it easy to differentiate from sibling tools like send_email and draft_email.

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

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

The description clearly frames when to use the tool: when you need to create a template rather than send an email. It also explains the conditional behavior based on organization settings, which helps the agent understand the context. It does not name alternative tools explicitly, but the 'not sending' clarification provides enough directional 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 only say readOnlyHint=false and destructiveHint=false; the description adds substantial behavioral detail: it creates drafts, never publishes, is quota-limited, may route through an approval proposal, and reports the outcome in a status field. This exceeds what annotations alone communicate and does not contradict them.

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

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

The three-sentence description is front-loaded with the core purpose and then delivers high-value caveats: draft-only, quota, approval behavior, and response status. There is no filler, and every clause contributes operational information.

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

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

Given 13 parameters, full schema coverage, and no output schema, the description covers the key behavioral caveats: draft state, quota, org-level routing, and the response status field. It is slightly incomplete on response shape beyond that status field, but overall the agent has enough context to invoke the tool correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description's list of 'name, type, dates, timezone, and optional venue/virtual details' mostly restates the schema rather than adding per-parameter meaning. It does add useful context like 'takes no eventId,' but not enough to justify a higher score.

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

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

The description opens with a specific verb and resource: 'Create a new DRAFT event for the organization,' and enumerates the relevant fields. It also clearly differentiates from publishing or updating tools by stating 'Never publishes — a human publishes in the app.'

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

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

The description provides clear operational context: events are draft-only, subject to quota, org-level with no eventId, and may either execute immediately or file a proposal depending on organization settings. It does not explicitly name sibling alternatives such as create_session, but the guidance is strong enough for an agent to understand when this tool applies.

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 indicate readOnlyHint=false and destructiveHint=false. The description adds meaningful behavioral context: the form is created as a draft, it is never published, it may execute immediately or file a proposal for approval depending on org settings, and the response status field reveals which path occurred. This goes well beyond the structured annotations and is not contradictory.

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 tight sentences with no filler. The most important constraint — DRAFT, never active/published — is front-loaded, and the approval/execution nuance follows naturally. 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?

The description covers the critical outcomes: draft creation, immediate execution vs. proposal approval, and the status field indicating which occurred. Since there is no output schema, a bit more detail about the response shape would be helpful, but the reference to the response status field provides enough orientation for an agent. Overall it is nearly complete.

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

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

Schema description coverage is 100%, so the schema fully documents every parameter. The description does not add additional meaning to individual parameters, but it also does not need to because the schema already covers them. 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 a new event form'. It also identifies the key distinguishing trait — the form is created as a DRAFT and never active/published — which separates it from tools like update_form or list_forms. This is specific and unambiguous.

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

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

The description gives clear context for when to use the tool: whenever you need to create a new event form. It also communicates an important exclusion — the form will never be active/published — and notes the approval-vs-immediate execution behavior. It does not explicitly name sibling alternatives or say 'use list_forms to view drafts', so it stops 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?

Annotations already indicate this is a non-read-only, non-destructive operation. The description adds meaningful behavioral context beyond that: the session is created unscheduled/proposed, and execution may either happen immediately or be routed through an approval workflow, with the response status field indicating which occurred. This is valuable transparency for an agent.

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

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

Two focused sentences that front-load the core action and status, then add the important approval-behavior nuance. Every sentence earns its place with no filler or redundancy.

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

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

For a complex creation tool with 11 parameters and no output schema, the description covers the key behavioral outcome, the approval variation, and how to interpret the response. It omits deeper side-effect details like permission prerequisites or idempotency, but the schema already documents request_id and parameter constraints, so this is reasonably complete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add parameter-level details beyond the schema, but it also does not need to, since all parameters already have descriptive text. It does hint at the response status field but not specific parameters.

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

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

The description clearly states the verb ('create'), the resource ('session'), and the target context ('for the event, unscheduled in the 'proposed' status'). This distinguishes it from related siblings like create_session_from_submission and schedule_session by specifying the initial state and workflow.

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 useful context about the proposal-vs-immediate behavior and notes the 'proposed' status, implying this is the initial creation step. However, it does not explicitly state when to prefer this over create_session_from_submission, schedule_session, or update_session, so routing guidance remains implicit rather than explicit.

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

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

The description discloses the conditional behavior beyond the annotations: execution may happen immediately or result in a proposal for approval, and the response status indicates which. This is valuable behavioral context that readOnlyHint=false and destructiveHint=false alone do not provide.

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

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

Two sentences, both information-dense and front-loaded with the core purpose. No filler or repetition of schema content.

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

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

The description covers the main operational nuance (immediate vs. proposal) and points to the response status field. It leaves exact status values and error behavior unspecified, but with 100% parameter schema coverage and no output schema required, it is sufficiently complete for tool selection and invocation.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds extra meaning by specifying that the submission must be approved, which clarifies submissionId beyond the schema's bare description. It also informs the agent about a response status field, helping interpret output even without an output schema.

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

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

The description uses a specific verb and resource: 'Turn an approved form submission into a session.' This clearly distinguishes the tool from generic create_session and schedule_session by tying it to an existing approved submission.

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 clear context about when this tool applies: only for approved form submissions, with behavior depending on organization settings. It does not explicitly name alternatives like create_session, but the approved-submission prerequisite makes the selection clear enough.

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

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

The description goes beyond the annotations by revealing a key behavioral nuance: depending on organization settings, the task either executes immediately or files a proposal for approval, and the response status field indicates which occurred. This is genuinely useful context that annotations alone do not provide. It does not cover permissions or reversibility, but the annotations already signal this is not read-only and not destructive.

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

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

The description is two sentences with no filler. The core purpose and examples are front-loaded, and the critical approval-versus-immediate behavior is stated succinctly in the second sentence. 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?

For a create tool with no output schema, the description usefully flags the response status field and the dual execution/approval path. The schema covers all parameters, so nothing critical about invocation is missing. It could be slightly richer on what happens after a proposal is filed, but the description is largely sufficient 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%, so the schema already documents every parameter. The description adds little parameter-level meaning beyond examples tied to the 'type' enum, which the schema already enumerates. This is the appropriate baseline for fully covered schemas.

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

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

The description states a specific action ('Create a portal task for a speaker') and gives concrete examples such as bio update and photo upload, so the resource and intent are clear. It does not explicitly differentiate from siblings like send_speaker_message or request_media_upload, though 'portal task' is a distinct enough noun to avoid major confusion.

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

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

The description implies when to use the tool: when you need to create a portal task for a speaker, with types like bio_update or photo_upload. However, it does not state when not to use it or mention alternatives such as send_speaker_message or request_media_upload, leaving some routing 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 only provide readOnlyHint=false and destructiveHint=false, which do not convey the subtle behaviors. The description adds crucial details: no duplicate detection, field limitations, immediate vs. proposal workflow, and the response status field. It also implicitly signals that the response may differ from a simple creation confirmation. This substantially exceeds what annotations provide.

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

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

Four sentences, front-loaded with the critical duplicate-check warning, then the field limitations, then the workflow variance. Each sentence earns its place and there is no filler or repetition. The structure follows the agent's decision-making needs.

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

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

Given no output schema, the description tells the agent the response status field indicates execution vs. proposal, but doesn't describe the full response shape (e.g., the created sponsor object). However, it covers the non-obvious behaviors: duplicates, field limitations, request_id semantics, and conditional execution. With 8 params and no output schema, a slightly more detailed response description would be ideal, but the core guidance is complete enough. The missing return format is a minor gap.

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

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

Schema coverage is 100% and many parameters have descriptive comments (e.g., request_id, customFields, org). The description adds value by warning about the request_id's idempotency semantics and custom field key matching, which are not fully captured in the schema. It doesn't need to restate each parameter, and it adds meaningful guidance for the trickiest ones. Loses one point because it doesn't explicitly warn that name is required or that website/hasBooth are optional, but the schema already says that.

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

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

The description states a specific action ('Create a sponsor') and immediately distinguishes itself by warning to check list_sponsors first, which differentiates it from update_sponsor and other sponsor-related tools. It also clarifies what it cannot do (set tier, logos, primary contact), which removes ambiguity. This is a precise verb+resource pairing with clear scope.

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

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

The description explicitly says to check list_sponsors first, names the alternative (UI) for fields not supported here, and explains the conditional execution path. It also warns about retries with request_id, making when-to-use and when-not-to-use unmistakable. This is exemplary 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 signal this is a write operation (readOnlyHint false) and not destructive (destructiveHint false). The description adds useful behavioral context beyond that: the operation may execute immediately or file a proposal depending on organization settings, and the response status field indicates which occurred. This gives the agent a clear expectation of side effects and how to interpret the result.

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

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

The description is two sentences with no filler. It front-loads the core action and batch capacity, then adds the conditional execution behavior and response hint in the second sentence. Every sentence contributes information the agent needs.

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

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

Given the rich input schema and annotations, the description covers the essential runtime behavior well, including the approval-proposal possibility and where to look in the response. A minor gap is that it does not mention how to handle already-decided submissions or what to do if the proposal path is taken, but this does not block correct invocation.

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

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

The schema already documents all parameters with 100% coverage, so the baseline applies. The description adds no per-parameter meaning beyond the schema; it repeats the batch limit already present in submissionIds.maxItems and references the response status rather than explaining any parameters.

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

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

The description uses a specific verb ('Accept or reject'), names the resource ('form submissions'), and adds a meaningful scope ('up to 25 in one call'). It is immediately distinguishable from siblings like set_submission_status because it explicitly frames the batch decision action.

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

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

The description clearly conveys when this tool is appropriate: for accepting or rejecting up to 25 submissions in one call, with an important conditional about immediate execution versus filing an approval proposal. It does not explicitly name an alternative tool for single submissions or non-decision status changes, so it stops short of full exclusion guidance.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the mutation and destructive nature are known. The description goes beyond by explaining the two possible outcomes (immediate execution vs proposal) and the need to inspect the response status field. It also warns that deletion is disabled by default and requires organizer authorization. This adds meaningful behavioral context beyond what annotations provide.

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

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

Two sentences with no filler: the first states the core destructive action, the second covers the two most important decision-relevant facts (allowed by default? immediate vs proposal, and how to know). 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?

For a destructive tool with full schema coverage, the description explains the precondition (organizer enablement), the async branch (proposal vs immediate), and how to interpret the outcome status field. It doesn't explicitly explain return values or error cases like non-existent session, but with no output schema defined and a clear schema, the description carries the essential burden. The only minor gap is what specific status values may appear.

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

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

Schema description coverage is 100%, so the schema fully documents all parameters including org precondition, eventId source, and request_id idempotency semantics. The description adds no new parameter-level information beyond the schema, but doesn't need to because the schema already explains the purpose of each parameter clearly.

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: 'Permanently delete a session.' It clearly distinguishes this from sibling tools like update_session or create_session, and from less destructive operations. The addition of 'permanently' signals severity unambiguously.

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

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

The description explicitly states when this tool is available: only when an organizer has enabled direct destructive access. It also explains that the operation may execute immediately or file a proposal depending on org settings, and directs the agent to check the response status field to tell which occurred. This gives clear context for when and how to use it, and implicitly warns against assuming immediate effect.

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

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

The annotations already mark destructiveHint=true and readOnlyHint=false, but the description adds essential behavioral context: deletion may be immediate or routed to an approval workflow depending on organization settings, and the tool may be disabled by default. It also clearly states that the response status field indicates the outcome. This goes well beyond the annotations and is critical for an agent to understand side effects and consequences.

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

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

The description is concise, front-loaded with the destructive intent, and packs critical workflow behavior into a few sentences without redundancy. Every sentence adds valuable context, and the warning is placed first, which is appropriate 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?

For a destructive write operation with no output schema, the description effectively explains the behavioral variability (immediate vs. proposal), the access requirement, and how to interpret the response. Given the tool's complexity and risk, this is complete and highly actionable.

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

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

The input schema already documents all parameters with 100% coverage, including the request_id idempotency semantics. The description does not add much beyond the schema, but it indirectly supports the semantics by explaining proposal-vs-immediate outcomes, which complements the request_id idempotency field. Since the schema covers parameter details thoroughly, a score of 4 reflects the schema leverage with a small descriptive boost.

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

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

The description clearly states the tool deletes a sponsor and emphasizes it is destructive and disabled by default. It also explains the two possible outcomes (immediate execution or proposal filing), which distinguishes it from other tool actions (e.g., update_sponsor, list_sponsors). This is unambiguous and task-specific.

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

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

The description explicitly warns about the destructive nature, notes that an organizer must enable direct destructive access, and tells the agent to check the response status field to know whether the action executed immediately or was filed as a proposal. This is strong guidance for when and how to invoke the tool, and it implies caution before calling it.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds valuable behavioral specifics beyond annotations: the output is size-capped, no email log is recorded, and a recipient preview is returned. Nothing contradicts the annotations.

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

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

Two focused sentences, front-loaded with the tool's core purpose and side-effect guarantee. Every clause earns its place; no filler or redundant restatement.

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?

There is no output schema, so the description's mention of the subject, merged HTML body (size-capped), and recipient preview adequately explains the return value. For a read-only preview tool, this is complete enough for an agent to select and invoke it correctly, especially alongside the schema-covered parameters.

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 all parameters. The description adds some value by explaining that contactId drives variable substitution, but it essentially restates the schema's 'variable-substitution context' wording. Overall, the description does not significantly extend the schema's parameter information.

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 ('Render') and resource ('an email template preview'), and immediately distinguishes it from sending by stating 'without sending anything.' This clearly differentiates it from sibling tools like send_email.

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

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

The description clearly communicates what the tool is for—previewing a rendered template—and what it does not do (send or log). It does not explicitly name send_email as the alternative, but the 'never sends' language strongly implies the appropriate use context.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context by specifying that results are grouped by day and room and time-sorted, which goes beyond the annotations. It does not mention pagination or response fields, but for a read-only agenda tool this is sufficient detail.

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

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

The description is a single sentence that front-loads the core behavior (agenda grouping and sorting) and appends the optional filtering capability. Every word contributes, with no wasted or repetitive content. This is a model of concise expression.

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

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

For a simple read-only tool with three parameters and no output schema, the description provides enough context: what the tool returns and how it is organized. It doesn't enumerate individual agenda fields, but the grouping and sorting information gives the agent a clear expectation. The missing output schema is partially compensated by the description's structural detail.

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

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

Schema description coverage is 100%, with each parameter already documented (eventId, day, org). The description echoes the day parameter's format and optionality but adds no new meaning beyond the schema. Thus the baseline of 3 is appropriate.

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

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

The description clearly identifies the tool as returning the event's scheduled agenda, with specific grouping by day and room and time-sorting, which distinguishes it from raw session listing tools like list_sessions. It lacks an explicit verb but the resource and output structure are unambiguous. It does not explicitly name sibling alternatives, so it falls short of a 5.

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

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

The description implies when to use the tool (any time the event's agenda is needed) and mentions the optional day filter, but it gives no explicit guidance on when not to use it or which alternatives to prefer. With sibling tools like list_sessions and get_session present, a brief routing note would have helped. Usage context 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 mark this as read-only and non-destructive. The description adds useful behavioral detail beyond that: it enumerates what the response contains and calls out that 'Free-text fields are labeled as untrusted content,' which is important for downstream handling. No contradiction with annotations.

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

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

The description is three concise sentences with no filler. It front-loads the core purpose, adds a conditional return nuance, and closes with a security-relevant warning. Every sentence earns its place.

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

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

For a read-only lookup with no output schema, the description covers the main return facets and a notable conditional field. It does not specify response shape or status codes, but that is not essential for an agent deciding whether to call this tool with eventId and contactId.

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

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

Schema description coverage is 100%, with org, eventId, and contactId all documented in the schema. The description adds no new parameter-level semantics, but it does not need to because the schema already provides adequate definitions and even names the source tools for 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?

The description uses a specific verb and resource: 'Get an event contact's profile, event status, sessions, and notes count.' It also names a conditional return value ('published speaker card link'), making the tool's purpose concrete and distinguishable from related tools like list_speakers, search_contacts, or update_contact.

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

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

The description clearly implies when to use this tool: when you need a single contact's aggregated profile and event-related details by eventId and contactId. It does not explicitly list exclusions or alternatives, but the scoped language and required IDs provide sufficient contextual 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 establish read-only and non-destructive behavior. The description adds concrete behavioral details: the 100-item cap, recency, allowed statuses, and optional contact filter. It does not disclose ordering or pagination, but that is a minor gap given the safety annotations.

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

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

The description is a single sentence with no filler. It front-loads the main action and result limit, then covers status values and the optional filter. Every phrase adds information without redundancy.

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

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

With a simple three-parameter schema and no output schema, the description conveys the output domain, the optional contact filter, and the event scope. It leaves ordering and the precise meaning of 'recent' implicit, but an agent can still select and invoke the tool correctly.

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

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

All three parameters are fully described in the schema with 100% coverage, including the meaning and source of eventId and org. The description only adds the optional contact filter and the 'recent' constraint, which is useful but not necessary because the schema already documents each parameter well.

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

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

The description names a specific verb ('List'), a bounded resource ('up to 100 recent event email sends'), and explicitly enumerates the statuses returned. This clearly distinguishes it from sibling email tools such as send_email or list_email_templates.

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

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

The description implies the use case clearly: retrieve recent event email send statuses, optionally filtered to one contact. It does not explicitly state when not to use it or name alternatives, but the context is strong enough to route an agent away from email creation and template tools.

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

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

Annotations already establish readOnlyHint=true and destructiveHint=false, so the safe read nature is covered. The description adds value beyond those annotations by disclosing the response shape (stats with specific counters) and a known limitation (registration counts absent). This is useful behavioral context for an agent deciding whether to invoke the tool.

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

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

The description is a single sentence with no filler. It front-loads the core purpose, then enumerates the specific content included, and ends with a clear caveat. 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?

For a low-complexity, read-only tool with only two well-documented parameters and no output schema, the description provides a complete mental model of what the tool returns and its limitation. An agent has enough information to select and invoke it correctly.

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

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

Schema description coverage is 100%, with both eventId and org already documented meaningfully (eventId as returned by list_events; org as returned by list_my_orgs). The description does not add parameter-specific semantics, but with full schema coverage the baseline of 3 is appropriate.

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

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

The description opens with a specific verb and resource: 'Get one event's overview.' It enumerates the exact content covered (details, venue, deep links, live counters) and the named stats categories, making it clearly distinguishable from sibling tools like get_session, get_agenda, and get_registration_stats.

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

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

The description clearly frames when to use this tool: to retrieve a single event's overview with counters. It also provides an explicit exclusion—'Registration counts are not included yet'—which signals that a different tool (e.g., get_registration_stats) is needed for that data. It does not name the alternative explicitly, but the context is clear enough.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds valuable behavioral context beyond annotations by stating that the tool returns configured:false when no ticketing rail is configured, which is a meaningful edge-case behavior an agent should know.

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

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

The description is a single, front-loaded sentence that states the core purpose first and then adds the key caveat about configured:false. Every word earns its place, with no redundancy or filler.

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

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

There is no output schema, so the description must carry some burden for explaining return values. It partially does by naming the active ticketing provider rail and the configured:false sentinel, but 'registration statistics' is vague and does not specify what fields or metrics will be returned. The description is adequate for invoking the tool but not fully complete for downstream 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 both eventId and org are already documented in the schema. The description adds no additional parameter-level meaning beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description clearly states a specific verb and resource: 'Get registration statistics and the active ticketing provider rail.' This is distinct from sibling tools like get_event, get_agenda, and get_review_progress, so an agent can identify it as the registration-stats tool without opening the schema.

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

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

The description implies when to use the tool but gives no explicit guidance, exclusions, or alternatives. There is no statement like 'use this when you need registration counts' or 'instead of list_attendees.' The intended usage is fairly obvious from the name and description, but the guidance is implicit rather than explicit.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds useful behavioral context by spelling out what the response covers (review rounds, completion percentages, pending decisions) and by scoping the operation to a single event, which goes beyond the tool name.

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

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

The description is one compact sentence with no filler. The main output categories are front-loaded and every word contributes to understanding the tool's purpose.

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

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

For a simple read-only getter with one required parameter, the description is reasonably complete: it names the output areas and clearly scopes to an event. Without an output schema, a bit more detail about the shape of review rounds would be helpful, but the description still gives enough for correct invocation.

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

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

Schema description coverage is 100%, with clear descriptions for eventId and org. The description adds no new parameter-level detail beyond 'for an event,' 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 uses a specific verb ('Get') and names concrete resources: review rounds, completion percentages, and pending decisions, all scoped to an event. This clearly differentiates it from sibling tools like get_event or list_pending_approvals.

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

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

The description implies the use case: when you need review progress for an event. However, it does not explicitly state when to prefer this over related alternatives or when not to use it, so the usage guidance is only implied.

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

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

Annotations already establish readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds useful context about the deep link and confirmation status, but does not address behavior for missing or invalid session IDs or any edge-case responses.

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?

This is a single, front-loaded sentence with zero filler. It states the scope and enumerates the key return fields efficiently.

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

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

There is no output schema, so the description's enumeration of returned fields is essential and well handled. It leaves minor gaps such as explicit guidance against using this for list-style queries, but overall it is sufficient for a simple single-session fetch.

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

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

Schema description coverage is 100%, with eventId, sessionId, and org all documented. The description adds no additional parameter-level meaning, so the schema carries the full burden as expected.

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 ('Get') and resource ('one session') and enumerates the returned contents: description, speaker roster with confirmation status, room, track, time, and a deep link. This clearly distinguishes it from siblings like list_sessions and get_agenda.

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 makes clear this is for retrieving a single session in full, which implies use when complete session details are needed. It does not explicitly name alternatives or state when not to use it, but the context is reasonably clear.

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

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

The description goes beyond the basic readOnly/destructive hints by disclosing that contacts are never duplicated, that emails are never sent, and that execution may be immediate or deferred as a proposal depending on organization settings. It also tells the agent to check the response status field to determine which occurred.

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

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

The description is compact and front-loaded with the most important operational constraint (batch size), followed by deduplication behavior, the no-email guarantee, routing to a sibling tool, and approval-mode nuance. Every sentence contributes useful operational 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?

Despite the lack of an output schema, the description explains the key outcome ambiguity by mentioning the response status field and the proposal-approval possibility. Combined with the rich input schema and explicit chunking/deduplication semantics, nothing critical is missing for correct invocation.

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

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

Schema coverage is 100%, but the description adds valuable meaning beyond the schema: the 50-item limit is framed as a chunking rule, and email is explained as the matching key for deduplication. This helps the agent choose and structure arguments correctly.

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

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

The description states a clear verb and resource: import 1 to 50 contacts into the CRM per call. It differentiates itself from sibling tools by specifying the batch limit, the deduplication-by-email behavior, and the explicit relationship to invite_to_portal.

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 concrete usage guidance: chunk larger sets into multiple calls, and use invite_to_portal afterward when portal access is needed. It does not exhaustively enumerate all sibling alternatives, but it clearly states the key routing decision.

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

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

The description discloses a key behavioral nuance beyond annotations: the action may execute immediately or file a proposal for approval, and the response status field indicates which occurred. This is valuable context because the tool can have delayed or contingent effects despite destructiveHint=true.

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

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

The description is two sentences with no filler. The primary action is front-loaded, and the conditional behavior is stated in the second sentence without unnecessary detail.

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

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

For a tool with no output schema, the description still tells the agent that the response includes a status field and what that field means. Combined with the fully described schema, this is sufficient for an agent to invoke the tool correctly. Minor missing details like approval workflow timing prevent a perfect score.

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

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

Schema description coverage is 100%, so the schema fully documents all parameters. The description does not add extra parameter-level detail, but the baseline of 3 applies because the schema already carries the semantic load.

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

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

The description uses a specific verb and resource: 'Grant a contact access to a portal and send the invitation email.' This clearly states the action and distinguishes it from contact note, email template, and general email tools among the 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 context is clear: use this when you need to grant a contact portal access and send the invitation. It also explains the two possible execution paths based on organization settings. It does not name explicit alternatives or when-not-to-use conditions, so it misses the top score.

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

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

Annotations already indicate readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context beyond annotations by specifying what the output contains and by warning that free-text fields are labeled as untrusted content, which is relevant for downstream handling.

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

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

The description is two sentences with no filler. The main function is front-loaded, the output contents are listed compactly, and the untrusted-content note is a meaningful addition that 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?

There is no output schema, so the description correctly takes on the burden of describing return values: names, email addresses, and relationship labels. The event and contact context are clear, parameters are fully documented in the schema, and annotations cover the read-only/destructive profile. This is sufficient for an agent to invoke and interpret the tool correctly.

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

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

Schema description coverage is 100%, so the schema already documents eventId, contactId, and org. The description does not add parameter-specific details beyond the schema, but it does not need to; the baseline of 3 is appropriate when structured parameter documentation is complete.

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

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

The description uses a specific verb ('List') and identifies a precise resource: a contact plus their associated people for one event, including names, email addresses, and relationship labels. This clearly distinguishes it from tools like get_contact, list_attendees, or search_contacts by adding the 'for one event' scope.

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

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

The description establishes clear context: use this when you need a contact and their associated people for a specific event. It does not explicitly name alternatives or exclusions, but the event-scoped framing provides enough guidance to know when this tool is appropriate relative to broader or single-contact tools.

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

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

Annotations already mark the operation read-only and non-destructive. The description goes beyond that by disclosing the 200-item limit, the fields returned (ticket status and type), and the truncated flag that signals when results exceed the cap. It does not describe pagination or what to do when truncated, but the disclosed behavior is meaningful and consistent.

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 communicates the action, resource, limit, output fields, and truncation behavior with zero filler. Every element 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?

With no output schema, the description adequately summarizes the response as ticket status, ticket type, and a truncated flag. Combined with the well-described inputs and read-only annotations, an agent can invoke it correctly. Minor gap: it does not explain what to do if truncated or whether additional attendee fields are present, but this does not block correct usage.

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

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

Schema description coverage is 100%, and the parameter descriptions are strong: eventId is tied to list_events, org is scoped to list_my_orgs and only needed in multi-org contexts. The tool description itself adds no parameter details, but the schema carries the full burden, so the baseline score of 3 is appropriate.

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

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

The description uses a specific action verb 'List', identifies the resource as 'ticketed attendees for an event', and adds concrete scope: up to 200, ticket status and type, and a truncated flag. This clearly separates it from sibling tools like list_events and get_registration_stats, leaving no ambiguity about the tool's function.

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

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

The description gives clear context: use this tool when you need ticketed attendee details for a specific event, with an explicit 200-record cap. It does not explicitly name alternatives or exclusions, but the read-only, event-scoped purpose is unambiguous enough for an agent to select it correctly.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds behavioral value by stating that only names and IDs are returned, not full template content, and that both organization-level and event-level templates are included. It does not describe response format or pagination, but this is not a major gap given the simple read-only nature.

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

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

The description is one short, front-loaded sentence with no filler. It communicates the action, scope, and output limitation efficiently.

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

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

For a simple two-parameter read-only tool with fully described schema and safety annotations, the description is largely complete. It conveys the output scope ('names and ids only'), which helps an agent decide whether this tool fits the need. It could mention return format or pagination, but those are minor for correct invocation.

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

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

Schema description coverage is 100%, so the input schema already fully documents the org and eventId parameters. The description's 'organization and event' phrasing loosely maps to these parameters but adds no additional semantic detail 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 uses a specific verb ('List'), names the resource ('email templates'), and scopes it to 'organization and event'. It also explicitly limits the output to 'names and ids only', which distinguishes it from sibling tools like create_email_template, draft_email, and send_email.

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 read-only retrieval by saying 'List' and 'only', but it does not explicitly say when to use this tool versus alternatives like draft_email or send_email. There is no direct exclusion or alternative routing, leaving the usage context to be inferred.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds value beyond annotations by listing the fields returned and instructing reuse of eventId. No contradiction with annotations.

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

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

Two-sentence description with no filler. The purpose and returned fields are front-loaded, and the eventId usage note is a concise, valuable second sentence.

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

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

For a zero-required-param list tool with no output schema, the description covers the essential return fields and downstream usage. It omits optional details like pagination and ordering, but the tool's simplicity makes these non-critical omissions.

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?

Only one optional parameter with a complete schema description (100% coverage). The description doesn't discuss the org parameter, but the schema already fully explains it, 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 ('List') and resource ('the organization's events'), enumerates the returned fields, and indicates the eventId's downstream role. This clearly differentiates it from sibling tools like get_event and list_sessions.

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 context: use it to list events and then pass the returned eventId to event-scoped tools. It doesn't explicitly name alternatives or exclusions, but the chaining instruction gives an agent actionable usage guidance.

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

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

Annotations already mark the tool as read-only and non-destructive. The description adds useful behavioral context by specifying that results include status and per-status submission counts, and that forms are scoped to the event, going beyond the annotations without contradicting them.

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

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

Two sentences with no filler: the first states the core action and output, the second gives a necessary cross-tool usage hint. The most important information is front-loaded.

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

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

For a simple read-only list tool with full parameter coverage and annotations, the description is complete: it names the resource, the output summary, and the intended next step. An agent has enough to invoke it correctly.

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

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

Schema description coverage is 100%, so the parameters are already documented. The description adds only the event-scoping relationship and does not provide additional semantics beyond what the schema already states.

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: lists the event's application/submission forms, including status and per-status submission counts. It also differentiates from list_submissions by mentioning the formId handoff, making the tool's role clear.

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

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

The description provides a clear workflow cue: use the formId returned here with list_submissions. It implies when this tool is useful, but it does not explicitly state when not to use it or name alternative listing tools beyond the workflow reference.

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

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

The annotations already declare readOnlyHint=true and destructiveHint=false, covering the safety profile. The description adds useful context by stating the tool returns memberships with slug and role, but it does not go into further behavioral details such as authentication or scope limitations. This is adequate but not exceptional.

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

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

The description is two sentences with no filler. The primary action and output are stated first, and the usage guidance is front-loaded in the second sentence. Every word earns its place.

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

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

For a zero-parameter, read-only listing tool, the description is complete: it states what is returned (org slug and role), when to call it, and provides the necessary context for an agent to decide to use it. No output schema exists, but the described return fields are sufficient for this simple 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?

The tool has zero parameters, so the baseline is 4. There is no parameter information needed, and the description appropriately focuses on the output semantics instead, noting the returned fields include slug and role.

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 ('List') and a specific resource ('organizations you belong to'), and further specifies the output fields ('slug and role'). This clearly distinguishes it from the many other list_* siblings, none of which target organizations.

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

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

The description gives explicit when-to-use guidance: 'Call this first if an organization must be chosen, or when asked what you can access.' It does not mention when not to use it or name an alternative, but given the absence of a sibling list_orgs tool, this is sufficient context.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds a concrete limit of 50 and specifies the returned fields (tool name, summary, status, creation time, and an event deep link), which is useful behavioral context beyond the annotations.

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

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

One sentence with no filler. It front-loads the limit and the returned fields, which are the most decision-relevant details. Every part earns its place.

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

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

For a read-only list tool with a fully-documented schema and safety annotations, this is nearly complete. It doesn't mention pagination or what 'pending' means, and there is no output schema, but the listed return fields mitigate that. Minor gaps keep 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%, so the schema already documents both parameters. The description adds no additional parameter-level semantics beyond what the schema provides. Baseline 3 is appropriate because the schema carries the load.

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

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

The description states a specific action ('List'), a specific resource ('pending Coordinator approvals'), and lists the fields returned. It clearly distinguishes this from sibling list tools by the 'pending approvals' scope, though it does not explicitly name a sibling alternative.

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 for retrieving pending Coordinator approvals, a read-only listing. It does not explicitly state when to use this vs. other list tools, but the scope is clear enough that an agent can infer it should be used when pending approvals are needed. No exclusions or alternatives 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 readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds a meaningful behavioral detail: a hard cap of 200 returned sessions, and the available filter dimensions.

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

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

Two sentences, front-loaded with the core listing behavior and returned fields, then the filter options. Every word earns its place.

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

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

For a simple read-only list tool with no output schema, the description is complete: it names the returned fields, the 200-row cap, and all filter dimensions. Combined with the well-documented schema, an agent has everything needed to invoke it correctly.

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

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

Schema description coverage is 100%, with clear descriptions for all five parameters including eventId, trackId, status, scheduled, and org. The description lightly reinforces the filter options but adds no syntax or format details 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: 'List the event's sessions' with concrete returned fields and filter options. The plural scope clearly distinguishes it from siblings like get_session and list_submissions.

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?

Clear context is provided: use it to get a filtered read-only overview of sessions for an event, with status, track, and scheduling filters. It doesn't explicitly name alternatives or exclusions, but the intended use is unmistakable.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the tool is known to be safe. The description adds the 200-item limit and the specific data fields returned, which is useful behavioral context. It does not disclose ordering, pagination, or filtering behavior, but for a simple read-only list this is a minor 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, front-loaded sentence with no filler. The action, resource, limit, and return fields are all present, and every word earns its place.

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

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

Given the simple 2-parameter schema, full schema coverage, and safety annotations, the description covers the essential return information in the absence of an output schema. It could mention sorting or pagination, but 'up to 200' and the field list make the tool sufficiently understandable.

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

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

Schema description coverage is 100%, with both eventId and org documented in the schema. The description adds no parameter-specific meaning beyond what the schema already provides, so the baseline score of 3 is appropriate.

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

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

The description clearly states the action ('List'), the resource ('event speakers'), and the scope (up to 200), and enumerates the returned fields (name, title, company, session titles, confirmation state, contact id). This distinguishes it from siblings like list_attendees or list_sessions, which target different resource types.

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 no guidance on when to use this tool versus alternatives. It does not mention conditions, exclusions, or sibling tools such as list_attendees, get_contact, or list_sessions. The only clue is the resource name, which is insufficient for an agent choosing among many speaker- and event-related tools.

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

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

Annotations already establish that this is safe and read-only. The description adds value by specifying the exact returned fields (title, type, status, due date, assigned contact id), which matters because there is no output schema. It does not mention pagination or ordering, but these are minor for a simple list 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?

One tight, front-loaded sentence states the action, scope, and result fields without filler. Every phrase contributes to tool selection and 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?

For a low-complexity read-only tool with two parameters and full schema coverage, the description covers purpose and return shape in the absence of an output schema. It could add a note on when to prefer this over create/send task tools, but nothing essential to a correct call 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 eventId and org are already fully documented. The description's 'event's' phrasing lightly reinforces the eventId relationship but adds no parameter-level meaning beyond the schema.

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

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

The description uses a specific verb and resource: 'List the event's speaker portal tasks' and enumerates the returned fields. This clearly distinguishes it from write-oriented siblings like create_speaker_task and from content lists like list_speakers/list_sessions.

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 verb 'List' implies the intended use—retrieving task data for an event—but the description gives no explicit when-to-use guidance or exclusions. It does not point to alternatives such as create_speaker_task or send_speaker_reminder, leaving the agent to infer selection from naming.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false. The description adds behavioral value beyond that by disclosing the 200-item cap, the exact data fields returned, and the custom-fields aspect. This gives the agent a concrete expectation of what the call will yield without repeating the annotation safety profile.

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

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

Two concise sentences with no filler. The first sentence states the action, scope, limit, and return fields; the second provides actionable integration guidance. Every clause earns its place, and the most important information is front-loaded.

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

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

For a simple read-only list tool, the description is complete: it names required inputs implicitly through referencing event sponsors, the schema documents eventId and org, and the description enumerates the return fields with the 200-item cap. The annotations (readOnlyHint, openWorldHint=false, destructiveHint=false) fill the safety and completeness profile, so 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%, so both org and eventId are already documented in the input schema. The description does not repeat or enhance parameter semantics, though it does connect the returned sponsorId to follow-up tools. Baseline 3 is appropriate because the schema carries the parameter documentation burden.

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: 'List up to 200 event sponsors' and enumerates the returned fields (sponsor id, name, tier, website, description, booth flag, custom fields). It clearly distinguishes itself from sibling tools like create_sponsor, update_sponsor, and delete_sponsor by being the listing/read operation.

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 clear downstream guidance: 'Use the returned sponsorId with update_sponsor or delete_sponsor.' This implies the intended workflow of retrieving sponsors before modifying or deleting them. It doesn't explicitly discuss when not to use it, but there is no competing list-sponsors sibling, so the context is sufficient.

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

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

Annotations already establish read-only and non-destructive behavior, so the description's added value comes from disclosing the 100-item limit, newest-first ordering, output field preview, and especially the security note that submission content is untrusted data. This goes beyond the structured annotations and provides important context for safe agent 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 sentences with no wasted words: the first front-loads the core action and key constraints, the second covers a critical safety consideration. Every part earns its place.

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

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

Given the lack of an output schema, the description appropriately summarizes return fields and adds the untrusted-data warning. It is slightly incomplete because it does not specify the overall output shape (array of objects) or whether submission IDs are included for follow-up actions, but this is a minor gap for a simple read-only list tool.

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

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

Input schema coverage is 100%, so all four parameters already have meaningful descriptions. The tool description does not add new parameter-level details; it mentions 'status' as an output field rather than a filter, which is not a conflict but also does not enhance schema meaning. 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 ('List'), resource ('a form's submissions'), and clear scoping details (up to 100, newest first, fields returned). It distinguishes from siblings like list_forms and list_attendees by identifying exactly what resource is being listed and what data is included.

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 purpose is clear enough that the usage is implied: list submissions for a form. However, the description does not explicitly address when to use this tool versus alternatives like list_pending_approvals, decide_submission, or set_submission_status, nor does it mention 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 cover the read-only, non-destructive safety profile. The description adds modest behavioral context by noting that colors and capacities are returned only 'when present,' but it does not disclose pagination, response shape, or any other runtime 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?

A single sentence with no filler. The core action and scope come first, and the optional output details are appended compactly.

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

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

For a simple read-only list with one required parameter, the description plus schema and annotations are nearly sufficient. The only slight gap is the absence of a pointer to manage_tracks/manage_rooms when modification is needed, but this does not block correct invocation.

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

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

Schema description coverage is 100%, so the schema already documents both eventId and org. The description does not need to add parameter-level detail, and the term 'event's' aligns with the documented eventId.

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 ('List') and resource ('an event's tracks and rooms') and adds distinguishing details (track colors, room capacities). It clearly separates this read-only lookup from sibling management tools like manage_tracks and manage_rooms.

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 read-only phrasing ('List') implies this is the lookup counterpart to manage_tracks/manage_rooms, but no explicit when-to-use or when-not-to-use guidance is given. An agent can infer usage from the name and readOnlyHint, but the description itself does not say which alternatives to prefer.

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

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

The description goes beyond the annotations by disclosing important behavioral nuances: deletion is unsupported, and execution may be immediate or may file a proposal depending on organization settings. It also tells the caller that the response status field indicates which path occurred, which is valuable context for a mutation tool with no 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?

The description is two sentences long, front-loaded with the core purpose, and every sentence adds value: capabilities, a non-goal, and a critical behavioral caveat. There is no redundancy or filler.

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

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

For a tool with no output schema and moderately complex write behavior, the description covers the essential return signal ('the response status field says which happened') and the approval possibility. It is complete enough for most calls, though it does not elaborate on what the status field values are or how pending approvals are tracked afterward.

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 eight parameters are already documented in the input schema. The description adds only high-level context about create/rename and response behavior, but does not need to restate parameter details; without additional parameter-level insights, 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 names the exact operations ('Create or rename a room for the event') and explicitly states what is not available ('Deleting rooms is not available'). This clearly identifies the tool's resource and scope, distinguishing it from room-related siblings like list_tracks_rooms and manage_tracks.

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

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

The description clearly establishes when to use the tool: when creating or renaming rooms. It also prevents misuse by stating deletion is not supported. However, it does not explicitly name alternatives or state conditions such as 'to list rooms, use list_tracks_rooms,' so usage guidance is strong but not fully explicit.

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

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

Annotations only say readOnlyHint=false and destructiveHint=false; the description adds meaningful behavior: the operation may execute immediately or file a proposal for approval depending on organization settings, and the response status field indicates which occurred. It also clarifies that deletion is unsupported. This goes beyond the annotations without contradicting them.

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

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

Two sentences, front-loaded with the primary purpose, followed by the key limitation and the conditional approval behavior. Every sentence adds value and there is 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?

The description is complete enough for a mutating tool with a fully described schema: it states the actions supported, the unsupported delete action, and the important proposal-versus-immediate-execution behavior. Since there is no output schema, mentioning the response status field helps the agent interpret the result, though it does not detail the full response shape.

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 every parameter already has a clear description in the schema. The tool description adds no additional parameter-level guidance, which is acceptable because the schema carries the full burden. 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 uses a specific verb and resource: 'Create or rename a track for the event.' It clearly distinguishes the tool from siblings like list_tracks_rooms (listing) and manage_rooms (rooms, not tracks). Even though sibling alternatives are not named, the action and object are unambiguous.

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

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

The description gives clear context: this tool is for creating or renaming tracks, and it explicitly notes that deleting tracks is not available. It does not name sibling tools or state 'use X instead,' but the intended use cases are plainly stated and the delete exclusion prevents misuse.

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

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

The description adds meaningful behavioral context beyond the annotations: the operation may execute immediately or file a proposal for approval depending on organization settings, and the response status field indicates which occurred. It also explicitly clarifies the non-destructive nature regarding the contact, which aligns with and enriches destructiveHint=false.

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

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

The description is two sentences with no wasted words. It front-loads the primary action, adds a clarifying scope note, and then explains the variable behavior and response indicator. Every sentence contributes useful information.

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

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

For a write operation with no output schema, the description provides sufficient context: what is removed, what is not removed, the conditional approval behavior, and where to look in the response to understand the outcome. Combined with complete parameter schema descriptions, nothing critical is missing for an agent to invoke the tool correctly.

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

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

Schema description coverage is 100%, so the schema already documents all parameters including eventId, contactId, sessionId, request_id, and org. The description adds no additional parameter-level meaning, which is acceptable at the baseline of 3 given the complete schema coverage.

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

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

The description states a specific verb and resource: 'Remove a speaker assignment from a session.' It also clarifies that the contact itself is not deleted, which distinguishes this from contact deletion or session deletion tools. This is clear and easily distinguishable from siblings like assign_speaker and delete_session.

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

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

The description does not explicitly state when to use this tool versus alternatives such as assign_speaker or delete_session. It implies its purpose through the action and resource, but offers no exclusions, prerequisites, or decision guidance for an agent comparing sibling tools.

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

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

The description goes well beyond the annotations, which only state readOnlyHint=false, openWorldHint=false, destructiveHint=false. It reveals that the link is short-lived and one-time, that file bytes never pass through the AI or API, that the upload attaches automatically, and that the response status indicates whether the action executed or filed a proposal.

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?

All five sentences carry essential information: the purpose, the response contents, the direct-upload behavior, the verification step, and the approval-mode nuance. There is no fluff or repetition; each sentence earns its place.

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

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

Given there is no output schema, the description adequately summarizes the response by mentioning the URL and the status field. It also covers the follow-up verification via get_event and the org-settings variation. Minor gaps remain around failure modes and exact response shape, but the essentials for calling the tool correctly are 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 the baseline is 3. The description does not add parameter-specific meaning beyond the schema; it explains the overall flow but does not elaborate on eventId, request_id, intent, or org beyond what the schema already states.

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

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

The description names a specific verb and resource: 'Get a short-lived ONE-TIME upload link for the event's logo or cover image.' It clearly distinguishes this tool from siblings by focusing on upload-link generation for media, which no other sibling covers.

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 clear usage context: use it to obtain a media upload link, and verify the result afterwards with get_event. It also notes the organization-dependent behavior (immediate execution vs. proposal), which informs the agent about possible next steps. It does not explicitly name an alternative tool, but no direct alternative exists among siblings.

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

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

Discloses key non-obvious behavior beyond the annotations: on conflict it returns {scheduled:false, conflicts:[...]} instead of writing, and it may either execute immediately or file an approval proposal depending on org settings, with a status field indicating the outcome. This is exactly the operational context an agent needs.

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

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

Two dense sentences, no filler. The core operation is front-loaded, followed by the most important behavioral caveats. Every clause contributes useful 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 no output schema, the description covers the critical non-standard return shape on conflicts and the proposal-vs-immediate distinction. It omits some conditional parameter requirements (e.g., which fields are needed for each mode), but the schema descriptions already annotate those, so the tool is sufficiently complete for correct invocation.

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

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

Schema description coverage is 100%, so the schema already fully documents each parameter. The description adds no new parameter-level semantics beyond echoing the mode values in prose, 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 names the resource (session) and a precise set of operations ('Place, move, swap, or unschedule'), clearly distinguishing it from siblings like create_session, update_session, and delete_session. An agent can immediately tell this is the scheduling-mutation tool.

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

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

The description makes it implicitly clear that this tool is for schedule operations, but it does not explicitly contrast it with alternatives such as check_schedule_conflicts, update_session, or delete_session. There is no 'use this when' or 'instead of' guidance, leaving selection partly 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 mark the tool as read-only and non-destructive. The description adds behavioral value by disclosing a 20-result cap and permission-filtered access, which are not in the annotations and help set caller expectations.

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

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

Two concise sentences with no filler. The main action and resource are front-loaded, and the result-limit caveat is placed at the end without bloating the description.

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

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

For a simple read-only search tool with fully documented parameters and safety annotations, the description covers the key remaining concerns: access scope (accessible/permission-filtered) and result cap. The lack of an output schema is not a major gap for a generic search endpoint.

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 all three parameters. The description reinforces the eventId meaning via 'restrict results to one event' but adds no new parameter-level detail beyond the schema.

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

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

The description opens with a specific verb and resource ('Search accessible organization records by keyword'), making the core purpose clear. It broadly distinguishes from sibling tools like search_contacts by targeting general organization records, though it does not explicitly name the distinction.

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

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

It states a useful condition ('Optionally restrict results to one event') for the eventId parameter, and 'accessible' implies permission-scoped use. However, it gives no guidance on when to choose this over search_contacts or semantic_search, nor any exclusions.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds the page-size limit (50 per page) and the nextCursor return behavior, which are useful behavioral details. It doesn't mention whether search matches name/email/fields, but that's a minor gap given the annotations.

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

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

One concise sentence with no wasted words. It front-loads the main function and includes the most important operational detail (pagination limit and cursor).

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

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

For a read-only search/pagination tool with no output schema and full parameter documentation, the description covers the essential usage: searching, paging, and the cursor mechanism. It could note what fields are searchable or that results are sorted, but it is otherwise complete for an agent 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 description coverage is 100%, so the schema fully documents all three parameters: org, cursor, and search. The description reinforces the cursor's role ('Returns nextCursor for another page') but doesn't add new meaning beyond the schema. Baseline 3 is appropriate.

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

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

The description clearly states the tool's function: search or page through organization contacts, with a specific pagination limit (50 per page). It distinguishes itself from related contact tools like get_contact, list_associated_contacts, and update_contact by focusing on searching/paging through all org contacts.

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 conveys when to use it: when you need to search or page through contacts. It mentions the nextCursor pagination mechanism, which implies iterative use. It doesn't explicitly name alternatives or when-not-to-use, but the function is clear enough against siblings like get_contact or list_associated_contacts.

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 readOnlyHint annotation, the description adds meaningful behavioral context: the search is metered, permission-filtered, capped at 20 results, and optionally scoped to a single event. These details materially affect how an agent should use and interpret the 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 sentences, front-loaded with the core purpose and then key constraints. Every clause adds value: metered, hybrid vector/text, accessible org records, event filter, result cap, and permission filtering.

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

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

Given the annotations and 100% schema coverage, the description covers the essential invocation context and return limits. It does not describe the shape of individual results, but with no output schema that is a modest gap rather than a blocking one.

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 input schema already documents org, query, and eventId. The description's mention of optional event restriction loosely reinforces eventId, but adds little parameter-level meaning beyond the schema.

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

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

The description states a specific action and resource: running metered hybrid vector and text search over accessible organization records, with optional event filtering. It clearly distinguishes this from contact-specific searches like search_contacts, though it does not explicitly differentiate itself from the sibling tool 'search'.

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 use for semantic/hybrid search over organization records, but it gives no explicit guidance about when to prefer this over the sibling 'search' or 'search_contacts' tools. There are no stated exclusions, prerequisites, or alternative routing cues.

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 say not read-only and potentially destructive. The description adds valuable context beyond annotations: it may execute immediately or file for approval, and the status field tells which. It doesn't mention idempotency (though request_id schema covers that) or email deliverability, so minor room remains to disclose consequences of sending to a real recipient.

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 focused sentences, front-loading the verb, resource, and audience, then adding the approval distinction. Every word earns its place and no fluff.

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

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

For a single-email tool with rich schema and multiple sibling email tools, the description is complete enough to invoke correctly. It could state expected sender identity or recipient scope (single contact only) more explicitly, but the single-contact wording already handles recipient scope. No output schema means return values are not specified, but the status field hint compensates partially.

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

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

Schema description coverage is 100%, so baseline is 3. The description adds context that templateId can be org or event template and that behavior may be queued for approval, but it doesn't add much beyond the schema's detailed parameter descriptions. The schema already documents request_id semantics thoroughly.

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: sends a templated email to a single contact. It also differentiates itself from draft_email and send_speaker_message/send_speaker_reminder by emphasizing single-contact templated email behavior. The clarification that it may either execute or file a proposal adds a useful distinctive trait.

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 use for sending a single templated email and the response status field informs which path occurred, but it does not explicitly state when to prefer this over draft_email or send_speaker_message. It provides helpful context about approval workflows but no formal exclusion or alternative 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 indicate a non-read-only, potentially destructive write, and the description adds meaningful context beyond that: the outcome may be either immediate execution or a filed proposal for approval, with a response status field indicating which occurred. This is useful and non-redundant 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?

The description is two sentences with no filler: the first states the core action and the second provides the key behavioral caveat. Every sentence earns its place and the most important information is front-loaded.

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

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

The description covers the central ambiguity an agent needs to handle: the email may execute immediately or require approval, and the response status reveals which. It could be slightly more complete by naming the exact status field or values, but given the rich schema and annotations, this is a minor gap.

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

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

Schema description coverage is 100%, so the schema already documents all six parameters thoroughly, including body formatting rules and request_id semantics. The description adds no additional parameter-level meaning, matching the baseline of 3 for high schema coverage.

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

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

The description identifies a clear action ('Email a message to a speaker/contact') and a specific resource, which is more than a tautology. However, it does not explicitly differentiate this tool from siblings like send_email or send_speaker_reminder, so the agent must infer the distinction from the name and target audience.

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 instead of alternatives such as send_email, send_speaker_reminder, or draft_email. It explains a behavioral nuance (immediate execution vs. approval proposal) but does not state conditions for tool selection 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?

The description adds meaningful behavioral context beyond the annotations: it explains that the tool may either execute immediately or file a proposal for approval depending on organization settings, and that the response status indicates which happened. This is useful non-obvious behavior. Annotations already communicate the non-read-only and destructive nature, so the description does not need to repeat that.

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

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

The description is two sentences and front-loads the main action, then adds the key behavioral caveat. Every sentence contributes necessary information without fluff or repetition of schema details.

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

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

Given no output schema, the description usefully points to the response status field, which is essential for understanding the outcome. The schema covers the parameters thoroughly, and the annotations cover the write/destructive nature. A slight gap is that the description does not name the status field or possible values, but the provided context is likely sufficient for an agent to invoke and interpret the tool.

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

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

All 9 parameters are already described in the schema with 100% coverage, so the baseline is 3. The description does not add param-level semantics beyond what the schema provides, though it does reference the response status field, which helps the agent interpret the outcome. It does not degrade or contradict the schema.

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

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

The description states a specific verb ('Email') and resource ('a speaker ... about an outstanding portal task'), making the tool's core purpose immediately clear. It also naturally distinguishes itself from sibling tools like send_email and send_speaker_message by scoping the action to portal-task reminders.

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

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

The description implies the correct use case — sending a reminder about an outstanding portal task — but it does not explicitly contrast with alternatives such as send_email, send_speaker_message, or draft_email. There are no clear when-to-use or when-not-to-use instructions, though the intended context is inferable.

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

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

Annotations already indicate this is a write operation that is not flagged destructive, but the description adds meaningful behavioral context beyond that: whether the change executes immediately or becomes a proposal depends on organization settings, and the response indicates which path was taken. This helps the agent anticipate side effects and response semantics.

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

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

The description is compact, front-loaded with the core action, and uses only two sentences. The status list is directly useful, and the second sentence explains a critical behavioral nuance without unnecessary elaboration.

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

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

For a tool with seven parameters and no output schema, the description covers the most important ambiguity: whether the status change is immediate or requires approval. It also gives a hint about the response. It could be more complete by addressing error cases or how proposals are later resolved, but the schema and annotations fill many 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?

Input schema description coverage is 100%, so the parameters are already well documented in the schema. The description adds little new parameter-level meaning; it repeats the status enum values and mentions a response status field, but does not deepen understanding of org, note, request_id, or IDs beyond what the schema already provides.

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

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

The description clearly states the tool's action: moving a form submission through a defined pipeline of statuses, and it enumerates the five allowed states. This is specific enough to identify the resource and operation, though it does not explicitly distinguish itself from overlapping siblings like decide_submission or update_form_pipeline.

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

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

The description explains how the tool behaves (immediate execution vs. filing a proposal) but gives no direct guidance about when to choose this tool over alternatives. It does not name sibling tools or state conditions like 'use decide_submission when...' so an agent must infer usage purely from the name and general wording.

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

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

With only sparse annotations (readOnlyHint=false, destructiveHint=false), the description carries the full disclosure burden and does it thoroughly: it reveals the auth requirement, that every change notifies org admins, that confirm=false makes the call a no-op preview, and that direct mode auto-reverts after duration_hours unless permanent=true. These are behavioral facts none of the annotations or schema fields convey. No contradiction exists — destructiveHint=false is consistent because the tool itself deletes nothing; it merely grants later delete capability.

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?

Five dense sentences, each earning its place: purpose and modes are front-loaded first, followed by the auth constraint, preview/confirm behavior, auto-revert mechanics, permission flags, and the admin-notification side effect. The length is proportional to the tool's complexity (9 parameters, nuanced semantics), and 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 a complex policy tool with no output schema, the description plus the fully-described schema covers prerequisites, side effects, temporal auto-revert, and flag effects. The one gap is that the response shape on confirm=true is not characterized — though the request_id schema description references 'executed or proposed outcome', which partially hints at it. Minor, given the rich 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%: every one of the 9 parameters has a description, including mutual exclusivity between permanent and duration_hours and the default of 24 hours, so the baseline is 3. The description adds useful workflow context that ties parameters together (preview-to-apply progression, mode interactions, what the flags unlock), but it does not materially deepen per-parameter 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 — 'Change how this organization's AI clients write data' — and concretely defines the two modes: 'approve' (changes filed as proposals for human approval) and 'direct' (immediate execution). No sibling tool manages write-access policy, so the purpose is unambiguous and easily distinguished from the CRUD/communication siblings without naming one.

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 states clear prerequisites — 'Requires an owner or admin account connected via OAuth; API keys cannot call this' — and explains the confirm-gated workflow: without confirm=true nothing changes and the response is a preview. It does not explicitly name an alternative tool or say when not to use it, but no sibling competes for this access-control role, so the gap is minor.

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 indicate the tool is not read-only and not destructive. The description adds essential behavior beyond that: depending on organization settings, the update may not take effect immediately and may instead be filed as a proposal for approval, with the response status field indicating which happened. This materially changes how an agent should interpret the result.

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 focused sentences with no wasted words. The first sentence states the purpose and scope, and the second delivers the critical conditional behavior and response-status guidance. It is front-loaded and easy to parse.

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?

Despite having no output schema, the description covers the key behavioral outcome an agent needs to handle: whether the update executed immediately or was filed for approval, and how to tell which happened via the status field. The complex parameter details are already handled thoroughly by the schema, so the description is complete enough for correct invocation and interpretation.

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

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

The input schema already documents all 19 parameters with 100% coverage, including nuanced behavior for customFields and request_id. The description's mention of 'profile fields, tags, or custom fields' is a helpful summary but does not add meaning beyond the schema, so the baseline score of 3 applies.

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

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

The description names the exact resource ('a contact'), the action ('Update'), and the scope ('profile fields, tags, or custom fields') with a specific verb. This clearly distinguishes update_contact from sibling tools like update_session and update_sponsor.

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 clear usage context: it updates contact data, and the org settings determine whether it executes immediately or files an approval proposal. It does not explicitly list when to prefer a sibling tool such as add_contact_note, but the resource scope is specific enough to make the primary use case obvious.

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

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

The description goes well beyond the minimal annotations by disclosing that the tool operates conversationally, refuses active forms, and may either execute immediately or file an approval proposal depending on organization settings. It also tells the agent that the response status field indicates which path occurred, which is critical for interpreting the result.

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, each earning its place: purpose, restriction, and execution-mode behavior. The most important distinguishing trait ('DRAFT form') is front-loaded, and the response-handling note is succinctly placed at the end. No filler or redundancy.

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

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

For a write tool with no output schema, the description adequately covers the behavioral nuances an agent needs: draft-only target, possible approval workflow, and how to determine the outcome. The schema covers parameter details, and no critical missing context remains for correct invocation.

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

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

The input schema already provides 100% documentation coverage for all five parameters, including detailed descriptions for formId, eventId, request_id, and instruction. The description adds contextual framing around formId (draft-only) and instruction (natural-language edit), but does not add new parameter-level meaning beyond the schema.

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

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

The description states a specific action ('edit'), a specific resource ('a DRAFT form'), and the mechanism ('by instruction'), making it distinct from create_form and update_form_pipeline. The additional 'Active forms are refused' clarifies the exact scope of the tool.

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

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

The description clearly indicates when to use the tool: for draft forms only, with natural-language instructions. It explicitly calls out the exclusion of active forms, giving an unambiguous when-not. It does not name alternative tools for active-form edits, but the context is clear enough.

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

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

The description adds valuable behavioral context beyond the annotations: depending on organization settings, the write either executes immediately or becomes a proposal requiring approval, and the response status field indicates which happened. Since annotations only provide readOnlyHint=false and destructiveHint=false, this conditional behavior is meaningful and not otherwise disclosed.

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

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

The description is two sentences long, front-loaded with the main purpose and operation types, followed by the key conditional behavior. There is no filler or repetition of schema-level details.

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

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

The description covers the core replacement semantics, the conditional immediate-vs-proposal path, and directs the agent to the response status field for the outcome. Since there is no output schema, this pointer is helpful, though exact status values are not enumerated; overall it is sufficient for a mutation tool with a well-covered 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%, so all parameters such as request_id, org, formId, eventId, and statuses are already documented in the input schema. The description reinforces that statuses is the full replacement pipeline array but does not add substantial new parameter-level meaning beyond the schema.

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

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

The first sentence uses a specific verb ('Replace') and a concrete resource ('a form's submission pipeline stages'), and it enumerates the operations supported: add, remove, rename, reorder. This clearly distinguishes the tool from siblings like update_form or set_submission_status, which address different aspects of forms or submissions.

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

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

The description clearly states what the tool is for, giving the agent a direct trigger condition for replacing pipeline stages. It does not explicitly name alternatives or explain when not to use it, but the conditional execution note also helps the agent set expectations about the outcome.

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 provide readOnlyHint=false and destructiveHint=false. The description adds crucial behavioral context: the update may either execute immediately or be filed as a proposal for approval depending on organization settings, and the response status field indicates which occurred. This is exactly the kind of nuance annotations cannot express.

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: the first names the action and scope, the second surfaces the approval workflow and response status. It is front-loaded, free of filler, and does not repeat structured schema content.

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

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

For a 21-parameter write tool with no output schema, the schema carries the parameter documentation well and the description adds the key behavioral caveat. The only notable gap is that the full response shape beyond the status field is not described, but the most important return detail is mentioned.

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 schema already documents parameters thoroughly (e.g., request_id idempotency, exact-name constraints, customFields merge behavior). The description itself adds no parameter-level detail, so the baseline score of 3 applies.

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

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

The description states a specific verb ('Update') and resource ('a session'), and enumerates the exact areas it affects: content, taxonomy, schedule, or custom fields. This makes it clear the tool targets existing sessions and implicitly distinguishes it from create_session and delete_session.

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 clear context for when to use the tool: when you need to modify an existing session's content, taxonomy, schedule, or custom fields. It also explains the org-dependent approval behavior, but it does not explicitly name alternatives or state when not to use it, so it stops 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.